P. 1
Guia de Iniciación al Lenguaje de Java

Guia de Iniciación al Lenguaje de Java

|Views: 71|Likes:
Publicado porRsolaris002

More info:

Published by: Rsolaris002 on Feb 13, 2011
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

02/13/2011

pdf

text

original

Guía de iniciación al lenguaje Java.

Versión 2.0. Octubre de 1999
Página 1 de 189
GUÍA DE INICIACIÓN AL LENGUAJE JAVA
VERSIÓN 2.0 Noviembre de 1999
SUBVENCIONADO POR: REALIZADO EN:


RESUMEN
Este trabaio corresponae a una guia (que sera presentaaa en formato HTML) que sirva
ae iniciacion a la programacion en el lenguaie Java. En el se tratan los aiversos
aspectos basicos que comprenaen el aprenaizaie ae un lenguaie ae programacion. asi
como una breve nocion ae la Programacion Orientaaa al Obieto en la que Java se
basa.
Asi mismo se incluven comparativas con otros lenguaies ae programacion (especial
hincapie en C¹¹). v se tratan con un poco mas ae profunaiaaa bibliotecas graficas
como AWT v Swing.
Se comentan tambien aspectos relacionaaos con Internet. como son las bibliotecas ae
Sockets v las famosas applets Java.
PALABRAS CLAVE
Java. Tutorial. Lenguaie ae programacion. Programacion Orientaaa a Obietos. Applet.
Coaigo ae Bvte. Clase. Obieto. Internet. Socket. Sun. JDK. Tutorial. Coaigo fuente.
C¹¹.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 2 de 189
ÍNDICES
ÍNDICE DE CONTENIDOS
Resumen............................................................................................................................................... 1
Palabras clave....................................................................................................................................... 1
ÍNDICES ..........................................................................................................................2
Índice de contenidos............................................................................................................................. 2
Índice de imágenes............................................................................................................................... 6
Índice de tablas..................................................................................................................................... 6
AU1ORES.........................................................................................................................8
PRÓLOGO........................................................................................................................9
Prólogo de la primera versión de la guía de Java ................................................................................. 9
Prólogo de la segunda versión de la guía de Java............................................................................... 11
PREFACIO.....................................................................................................................12
Contenidos ......................................................................................................................................... 12
Agradecimientos ................................................................................................................................ 14
1EMA I: IN1RODUCCIÓN..........................................................................................15
I.1. INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OB1ETOS ............ 16
A. Programación Orientada a Objetos................................................................................................ 16
B. Los objetos .................................................................................................................................... 16
C. Las clases....................................................................................................................................... 17
D. Modelo de objetos ......................................................................................................................... 17
E. Relaciones entre objetos ................................................................................................................ 19
I.2. HISTORIA DE 1AVA..................................................................................................... 21
A. ¿Por qué se diseñó Java? ............................................................................................................... 21
B. Comienzos ..................................................................................................................................... 22
C. Primeros proyectos en que se aplicó Java...................................................................................... 23
D. Resurgimiento de Java................................................................................................................... 23
E. Futuro de Java................................................................................................................................ 24
F. Especulación sobre el futuro de Java ............................................................................................. 25
I.3. CARACTERISTICAS DE 1AVA.................................................................................. 26
A. Introducción .................................................................................................................................. 26
B. Potente........................................................................................................................................... 26
C. Simple............................................................................................................................................ 27
D. Interactivo y orientado a red.......................................................................................................... 27
E. Y mucho más ................................................................................................................................. 29
I.4. COMPARATIVA CON OTROS LENGUA1ES DE PROGRAMACIÓN
ORIENTADOS A OB1ETO ................................................................................................. 31
A. Introducción .................................................................................................................................. 31
B. Comparación de los tipos de datos ........................................................................................... ..... 31
C. Operadores relacionales y aritméticos. .......................................................................................... 32
D. Vectores......................................................................................................................................... 32
E. Cadenas.......................................................................................................................................... 32
F. Otras características ....................................................................................................................... 32
1EMA II: FUNDAMEN1OS DEL LENGUA1E .........................................................3ô
II.1. FUNDAMENTOS.......................................................................................................... 37
A. Introducción .................................................................................................................................. 37
B. Tokens ........................................................................................................................................... 37
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 3 de 189
C. Expresiones.................................................................................................................................... 39
D. Bloques y ámbito........................................................................................................................... 40
II.2. TIPOS DE DATOS........................................................................................................ 42
A. Tipos de datos simples .................................................................................................................. 42
B. Vectores y Matrices....................................................................................................................... 45
C. Cadenas ......................................................................................................................................... 45
II.3. OPERADORES.............................................................................................................. 47
A. Introducción .................................................................................................................................. 47
B. Operadores aritméticos .................................................................................................................. 48
C. Operadores de comparación y condicionales................................................................................. 49
D. Operadores de bit .......................................................................................................................... 50
E. Operadores de asignación .............................................................................................................. 52
F. Precedencia de operadores ............................................................................................................. 52
II.4. ESTRUCTURAS DE CONTROL................................................................................ 54
A. Introducción .................................................................................................................................. 54
B. Las sentencias condicionales: if y switch ...................................................................................... 54
C. Sentencias de iteración o bucles: for, do, while............................................................................ . 57
D. Sentencias de salto: break, continue y return............................................................................... .. 58
E. Excepciones ................................................................................................................................... 61
II.5. CLASES Y OB1ETOS .................................................................................................. 62
A. Introducción .................................................................................................................................. 62
B. Definición de una clase.................................................................................................................. 63
C. La instanciación de las clases: Los objetos................................................................................. ... 65
D. Acceso al objeto ............................................................................................................................ 67
E. La destrucción del objeto............................................................................................................... 68
II.6. LA HERENCIA............................................................................................................. 70
A. Introducción .................................................................................................................................. 70
B. Jerarquía ........................................................................................................................................ 70
C. Herencia múltiple .......................................................................................................................... 70
D. Declaración.................................................................................................................................... 71
E. Limitaciones en la herencia ........................................................................................................... 71
F. La clase Object............................................................................................................................... 72
II.7. OPERACIONES AVANZADAS EN LAS CLASES.................................................. 74
A. Introducción .................................................................................................................................. 74
B. Operaciones avanzadas en la herencia........................................................................................... 74
C. El polimorfismo............................................................................................................................. 76
D. las referencias polimórficas: this y super ...................................................................................... 78
E. la composición............................................................................................................................... 79
II.8. GESTIÓN DE EXCEPCIONES Y ERRORES........................................................... 80
A. Introducción .................................................................................................................................. 80
B. Tipos de excepciones..................................................................................................................... 80
C. Funcionamiento............................................................................................................................. 81
D. Excepciones que incorpora Java 1.2.............................................................................................. 85
II.9. INTERFACES ............................................................................................................... 87
A. Introducción .................................................................................................................................. 87
B. Declaración.................................................................................................................................... 87
C. Implementación de una interfaz..................................................................................................... 87
D. Herencia múltiple .......................................................................................................................... 88
E. Colisiones en la herencia múltiple ................................................................................................. 88
F. Envolturas de los tipos simples............................................................................................. ......... 89
II.10. PAQUETES.................................................................................................................. 90
A. Introducción .................................................................................................................................. 90
B. Creación de un paquete.................................................................................................................. 90
C. Uso de un paquete ......................................................................................................................... 91
D. Ámbito de los elementos de un paquete ........................................................................................ 91
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 4 de 189
II.11. LOS THREADS O PROGRAMACIÓN MULTIHILO........................................... 93
A. Introducción .................................................................................................................................. 93
B. Utilización de thread...................................................................................................................... 93
C. Sincronización de threads.............................................................................................................. 94
D. Y mucho más................................................................................................................................. 96
II.12 CREACIÓN DE PROGRAMAS 1AVA..................................................................... 97
A. Introducción .................................................................................................................................. 97
B. Tipos de aplicaciones..................................................................................................................... 97
C. Recomendaciones de programación .............................................................................................. 98
D. Grandes programas........................................................................................................................ 99
1EMA III: BIBLIO1ECAS DE LA API DE 1AJA...................................................1ö1
III.1. BIBLIOTECAS DE LA API DE 1AVA................................................................... 102
A. Introducción ................................................................................................................................ 102
B. Paquetes de utilidades.................................................................................................................. 102
C. Paquetes para el desarrollo gráfico.............................................................................................. 102
D. Paquetes para el desarrollo en red ............................................................................................... 103
E. Para más información .................................................................................................................. 103
III.2. CADENAS .................................................................................................................. 104
A. Introducción ................................................................................................................................ 104
B. Métodos de la clase String........................................................................................................... 105
C. Métodos de la clase StringBuffer ............................................................................................ .... 107
D. Ejemplos de uso de cadenas ........................................................................................................ 108
III.3. ENTRADA/SALIDA.................................................................................................. 111
A. Introducción ................................................................................................................................ 111
B. Entrada/Salida estándar ............................................................................................................... 111
C. Entrada/Salida por fichero........................................................................................................... 112
1EMA IJ. BILIO1ECAS GRÁFICAS........................................................................118
IV.1. LOS PAQUETES GRÁFICOS DE LAS 1FC.......................................................... 119
A. Introducción ................................................................................................................................ 119
B. Modelo de eventos....................................................................................................................... 119
C. Subpaquetes de AWT.................................................................................................................. 120
D. Subpaquetes de Swing................................................................................................................. 121
IV.2. AWT (Abstract Windowing Toolkit)........................................................................ 122
A. Introducción ................................................................................................................................ 122
B. Component .................................................................................................................................. 122
C. Container ..................................................................................................................................... 124
D. Gestores de impresión ................................................................................................................. 124
E. Otras clases .................................................................................................................................. 124
F. Eventos de AWT.......................................................................................................................... 125
IV.3. SWING........................................................................................................................ 127
A. Introducción ................................................................................................................................ 127
B. Nuevas características.................................................................................................................. 127
C. Principales clases......................................................................................................................... 128
D. Nuevos gestores de impresión..................................................................................................... 129
E. JrootPane ..................................................................................................................................... 129
F. Nuevos eventos de Swing ............................................................................................................ 130
G. El patrón de diseño Modelo-Vista-Controlador .......................................................................... 130
1EMA J. 1AJA E IN1ERNE1...................................................................................132
V.1 1AVA E INTERNET .................................................................................................... 133
A. Introducción ................................................................................................................................ 133
B. El paquete java.net....................................................................................................................... 134
C. Futuro del Java en Internet .......................................................................................................... 134
V.2 LOS SOCKETS EN 1AVA .......................................................................................... 135
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 5 de 189
A. Fundamentos ............................................................................................................................... 135
B. Ejemplo de uso ............................................................................................................................ 136
1EMA JI: APPLE1S 1AJA........................................................................................139
VI.1. INTRODUCCIÓN A LAS APPLETS ...................................................................... 140
A. Introducción ................................................................................................................................ 140
B. Consideraciones sobre la seguridad en las applets ...................................................................... 140
VI.2. LA CLASE APPLET ................................................................................................. 142
A. Situación de la clase Applet en la API de Java............................................................................ 142
B. Métodos del ciclo de vida............................................................................................................ 142
C. La clase URL............................................................................................................................... 143
D. Inclusión de la applet en una página Web ................................................................................... 143
E. Obtención de los parámetros de la applet .................................................................................... 144
F. Obtención de Información sobre una applet ................................................................................ 144
G. Manipulación del entorno de una applet...................................................................................... 145
H. Soporte multimedia ..................................................................................................................... 145
VI.3. E1EMPLO DE CONSTRUCCIÓN DE UNA APPLET ......................................... 146
A. Código......................................................................................................................................... 146
B. Ejecución..................................................................................................................................... 146
C. Creación de applets más avanzadas............................................................................................. 147
D. Creación de una aplicación que utilice la applet (AWT)............................................................. 147
E. Creación de una aplicación que utilice la applet (Swing) ............................................................ 149
VI.4. E1EMPLOS DE APPLETS....................................................................................... 150
A. Instantáneas: “Tumbling Duke” .................................................................................................. 150
B. Animación y sonido: “Animator”................................................................................................ 151
C. Gráficos interactivos: “Link Button”........................................................................................... 152
D. Trucos de texto: “Nervous Text”................................................................................................. 153
E. Financias y negocios: “Bar Chart”............................................................................................... 153
F. Juegos y educacionales: “Graph Layout”..................................................................................... 155
APENDICES ................................................................................................................157
APÉNDICE I. EL 1DK (1ava Development Kit) .............................................................. 158
A. Introducción ................................................................................................................................ 158
B. Componentes del JDK................................................................................................................. 158
C. Uso del JDK ................................................................................................................................ 161
D. Obtención e instalación del JDK................................................................................................. 162
E. Novedades en la versión 1.2 del JDK (Java 2)............................................................................. 162
APÉNDICE II: HERRAMIENTAS DE DESARROLLO................................................ 164
A. Programas de navegación............................................................................................................ 164
B. Entornos de desarrollo................................................................................................................. 164
C. Bibliotecas de programación ....................................................................................................... 167
APÉNDICE III: MÉTODOS NATIVOS 1AVA (1NI) ..................................................... 168
A. Introducción ................................................................................................................................ 168
B. Ejemplo de uso de métodos nativos........................................................................................... .. 168
APÉNDICE IV: GUIA DE REFERENCIA DE C++ A 1AVA........................................ 171
A. Introducción ................................................................................................................................ 171
B. Diferencias sintáticas................................................................................................................... 171
C. Diferencias de diseño................................................................................................................... 172
D. Diferencias de ejecución ............................................................................................................. 173
APÉNDICE V: GUIA DE REFERENCIA DEL LENGUA1E 1AVA ............................ 175
A. Fundamentos ............................................................................................................................... 175
B. Tipos de datos.............................................................................................................................. 175
C. Operadores................................................................................................................................... 176
D. Estructuras de control.................................................................................................................. 177
E. Clases........................................................................................................................................... 178
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 6 de 189
F. Atributos ...................................................................................................................................... 178
G. Métodos....................................................................................................................................... 179
H. Objetos ........................................................................................................................................ 179
I. Interfaces....................................................................................................................................... 179
J. Paquetes........................................................................................................................................ 180
K. Excepciones................................................................................................................................. 180
L. Threads ........................................................................................................................................ 181
GLOSARIO...................................................................................................................182
BIBLIOGRAFÍA..........................................................................................................188
A. Bibliografía consultada para la actual versión:............................................................................ 188
B. Bibliografía adicional o citada en la actual versión: .................................................................... 189
C. Bibliografía adicional que se utilizó en la versión 1.0................................................................. 189
D. Direcciones de interés ................................................................................................................. 189

ÍNDICE DE IMÁGENES
Imagen 1: Eiemplo de árbol de herencia.......................................................................18
Imagen 2: Logotipo de la empresa Sun Microsvstems..................................................22
Imagen 3: Icono de Duke, la mascota de 1ava..............................................................23
Imagen 4: Eiemplo de otro árbol de herencia...............................................................7ö
Imagen 5: Herencia de excepciones 1ava .....................................................................8ö
Imagen ô: Eiemplo de herencia múltiple ......................................................................88
Imagen 7: 1erarquía de las clases de AW1.................................................................122
Imagen 8: Diferentes aspectos de una interfaz Swing................................................127
Imagen 9: Eiecución de un código de bvte..................................................................133
Imagen 1ö: Funcionamiento de una conexión socket................................................135
Imagen 11: Ciclo de vida de una applet ......................................................................142
Imagen 12: Applet ~Línea¨..........................................................................................147
Imagen 13: Applet Instantánea "1umbling Duke" ....................................................15ö
Imagen 14: Applet de Animación v sonido "Animator".............................................151
Imagen 15: Applet de gráficos interactivos "Link Button"........................................152
Imagen 1ô: Applet de texto animado "Nervous 1ext"................................................153
Imagen 17: Applet de financias v negocios "Bar Chart" ...........................................153
Imagen 18: Applet de iuegos v educacionales "Graph Lavout".................................155
Imagen 19: Utilización del 1DK...................................................................................1ô1

ÍNDICE DE TABLAS
1abla 1: Comparación entre 1ava, Small1alk v C++ ...................................................33
1abla 2: Palabras reservadas 1ava................................................................................38
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 7 de 189
1abla 3: Operadores 1ava ..............................................................................................39
1abla 4: Formatos de comentarios 1ava .......................................................................39
1abla 5: 1ipos de datos enteros......................................................................................42
1abla ô: 1ipos de datos numéricos en coma flotante..................................................43
1abla 7: Caracteres especiales 1ava..............................................................................44
1abla 8: Conversiones sin pérdidas de información.....................................................45
1abla 9: Operadores aritméticos binarios de 1ava........................................................48
1abla 1ö: Jersiones unarias de los operadores "+" v "-" ...........................................48
1abla 11: Operaciones con "++" v "--"........................................................................48
1abla 12: Operadores de comparación..........................................................................49
1abla 13: Operadores condicionales .............................................................................49
1abla 14: Operadores de desplazamiento de bits ..........................................................5ö
1abla 15: Operadores de lógica de bits..........................................................................5ö
1abla 1ô: Operadores de ataio de asignación...............................................................52
1abla 17: Prededencia de operadores............................................................................53
1abla 18: Estructuras de control ...................................................................................54
1abla 19: Jisibilidad dentro de un paquete...................................................................91
1abla 2ö: Conversiones de cadenas a tipos simples....................................................1ö7

Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 8 de 189
AUTORES

DIRECTOR DEL PROYECTO COORDINADOR TÉCNICO
Miguel Ángel Manzanedo del Campo Francisco José García Peñalvo
Área de Organización de Empresas Área de Ciencias de la Computación e
Inteligencia Artificial
Dpto. de Ingeniería Civil Dpto. de Informática y Automática
Universidad de Burgos Universidad de Salamanca

REDACTADO, EDITADO, AMPLIADO Y PUBLICADO POR:
Ignacio Cruzado Nuño
Becario del Área de Lenguajes y Sistemas Informáticos
Departamento de Ingeniería Civil
Universidad de Burgos

OTROS INVESTIGADORES
César Ignacio García Osorio
Jesús Manuel Maudes Raedo
Carlos Pardo Aguilar
Juan José Rodríguez Díez
Área de Lenguajes y Sistemas Informáticos Área de Lenguajes y Sistemas Informáticos
Departamento de Ingeniería Civil Departamento de Informática
Universidad de Burgos Universidad de Valladolid

ALUMNOS COLABORADORES EN LA VERSIÓN 1.0
Alumnos de la asignatura de “Programación Avanzada”, asignatura optativa del 3º
Curso de la Titulación de “Ingeniería Técnica en Informática de Gestión” en la
Universidad de Burgos. Alumnos del curso 1997-1998 (Primera promoción).
Rubén Cobos Pomares Ignacio Cruzado Nuño Fernando Delgado Peña
Raquel Díez Alcalde Alberto Díez Cremer Ana Berta García Benito
Jorge García del Egido Esteban José García Zamora Alberto Gómez Revilla
Ismael González Domingue Mª Begoña Martín Ortega Javier Portugal Alonso
Pablo Santos Luances David Suárez Villasante

Dirección electrónica del proyecto: qjava@ubu.es
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 9 de 189
PRÓLOGO
PRÓLOGO DE LA PRIMERA VERSIÓN DE LA GUÍA DE JAVA
Java es actualmente uno de esos términos mágicos que revolucionan las tecnologías de
la información cada cierto tiempo. Java es un lenguaje de programación orientado a
objetos creado por la compañía Sun Microsystems, que desde su aparición en 1995 ha
provocado una autentica conmoción en los entornos informáticos. El éxito del lenguaje
Java viene de la mano de la filosofía y la forma de operación de las aplicaciones escritas
en Java, todo ello estrechamente ligado a Internet y al WWW.
El hecho de que el lenguaje Java sea un lenguaje joven en evolución no le ha permitido
entrar a formar parte habitualmente de los currículum universitarios, poco dados a
admitir innovaciones con tanta celeridad. Sin embargo, Java comienza a entrar en las
Universidades Españolas, especialmente de la mano de los proyectos de final de carrera
en las titulaciones de informática.
Aprovechando la convocatoria de 1998 de la Consejería de Educación y Cultura de la
Junta de Castilla y León para la concesión de ayudas para la elaboración de Recursos
de Apoyo a la Enseñanza Universitaria en esta Comunidad Autonómica, se decidió
realizar una actividad que tuviera como protagonista al lenguaje Java, a la vez que se
exploraba una nueva forma de involucrar de una manera más activa al alumnado en las
actividades docentes, así como de incentivar al profesorado en aras de conseguir una
docencia de mayor calidad.
La actividad que se propuso llevar a cabo fue una Guía Hipermedia para el Aprendizaje
del Lenguaje Java.
Con la realización de esta guía se perseguían una serie de objetivos tanto docentes como
pragmáticos. Los objetivos docentes estaban centrados en la búsqueda de la mejora de la
calidad docente, reflejada en una mayor participación de los alumnos y en una mejora
de la relación profesor-alumno. Los objetivos pragmáticos se centraban en el
acercamiento del lenguaje Java al curriculum de los alumnos matriculados en la
asignatura “Programación Avanzada” correspondiente al tercer curso de la titulación
“Ingeniería Técnica en Informática de Gestión en la Universidad de Burgos”.
A continuación se recogen tanto los objetivos docentes como los objetivos pragmáticos
propuestos.
Objetivos Docentes:
Œ Establecer una nueva forma de participación activa de los alumnos en el desarrollo
de su currículum universitario, en contraposición de la actitud pasiva que
tradicionalmente asume el alumno en las clases.
Œ Dotar a alumnos y profesores de las responsabilidades que conlleva la realización de
una actividad en grupo.
ΠCompletar los contenidos del curriculum universitario del alumno con temas
novedosos que no suelen tener cabida en el programa de las asignaturas.
Œ Aumentar la cantidad y la calidad de la relación profesor-alumno.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 10 de 189
Objetivos Pragmáticos:
Œ Introducir el lenguaje Java dentro de la titulación Ingeniería Técnica en Informática
de Gestión de la Universidad de Burgos.
Œ Elaborar una guía de referencia hipermedia del lenguaje Java accesible vía Internet y
distribuíble en CD-ROM. Esta guía podrá ser utilizada tanto para el autoaprendizaje,
como para material docente o como material de consulta en los proyectos de final de
carrera.
Œ Aprender de la experiencia para repetir esta técnica en otras asignaturas de la
titulación e incluso en otras Universidades.
Este proyecto se va a acometer en dos fases bien diferenciadas:
Una primera fase (Enero 1998 Diciembre 1998) donde se planifica todo el proyecto y
se obtiene una primera guía básica de referencia básica (proaucto que viene
representaao por la presente guia).
Una segunda fase (Enero 1999 Diciembre 1999) donde se amplía la primera guía
introductoria con los conceptos más avanzados del lenguaje y se enriquece de los
comentarios recibidos sobre la primera guía.
Para la realización práctica de esta primera guía se ha utilizado exclusivamente HTML
(Hyper Text Markup Language), debido a que sus características hipermedia lo hacen
idóneo para el desarrollo de este tipo de productos.
La metodología empleada para la creación de esta guía ha consistido en formar grupos
de trabajo formados por tres alumnos cada uno (los alumnos que formaban caaa uno ae
los grupos eran alumnos ae la asignatura Programacion Avanzaaa ael tercer curso ae
la Ingenieria Tecnica en Informatica ae Gestion ae la Universiaaa ae Burgos. que
voluntariamente se ofrecieron para colaborar en esta iniciativa). Cada grupo se
encargaba de elaborar una serie de temas que en su conjunto dan forma a la presente
guía, siendo su trabajo coordinado por alguno de los profesores colaboradores. Una vez
que los temas estaban terminados eran revisados e integrados en la guía por el
coordinador técnico del proyecto.

Burgos, 5 de Octubre de 1998
Miguel Ángel Manzanedo del Campo
Francisco José García Peñalvo
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 11 de 189
PRÓLOGO DE LA SEGUNDA VERSIÓN DE LA GUÍA DE JAVA
En los casi dos años en los que se ha venido desarrollando esta guía introductoria al
lenguaje Java, hemos asistido al afianzamiento de Java como plataforma de desarrollo y
a una constante evolución que, aunque todavía lejos de una madurez plena, ha abierto
numerosos campos de aplicación para esta plataforma (acceso a bases de datos,
interacción con CORBA, aplicaciones distribuidas...).
Durante este tiempo han proliferado multitud de referencias en torno al fenómeno Java
(en forma de libros, artículos, tutoriales...), sin embargo, la guía que hemos realizado no
pretende sustituir a ninguno de ellos, sino más bien completarlos presentando una forma
sencilla y directa de introducirse al lenguaje Java y ofreciendo un acceso sencillo
basado en la facilidad de navegación hipermedia que aporta HTML.
A parte de la guía realizada, como producto final resultado del proyecto financiado por
la Consejería de Educación y Cultura de la Junta de Castilla y León en su convocatoria
de ayudas de 1998, este proyecto ha aportado unas experiencias especialmente
interesantes al verse satisfechos los objetivos docentes y pragmáticos que se buscaban al
iniciar este trabajo, y que se indicaban en el prólogo a la primera versión de esta guía
que aquí se presenta.
Si personalmente, tuviera que destacar una sola cosa de esta experiencia, no dudaría en
destacar el valor humano logrado al potenciar la relación profesor-alumno (hoy en día
ex-alumnos) y entre compañeros de diferentes Universidades de Castilla y León para
lograr el fin extra académico propuesto.
También me gustaría destacar el hecho constatado de que la elaboración de esta guía a
contribuido en gran manera a la introducción del lenguaje Java dentro de la titulación de
Ingeniería Técnica en Informática de Gestión de la Universidad de Burgos, y está
haciendo lo propio en la Ingeniería Técnica en Informática de Sistemas de la
Universidad de Salamanca.
En el ámbito técnico destacar la revisión realizada de los contenidos de la primera
versión de la guía, así como la ampliación en temas relacionados con la programación
cliente/servidor en Internet, los entornos gráficos de usuario o la incorporación de
métodos nativos entre otros interesantes temas, que dan un enorme valor a esta guía
como fuente de referencia práctica.
No quisiera terminar este prólogo sin antes tener unas palabras de agradecimiento y
recuerdo para todos aquéllos que participaron de una u otra manera en la elaboración de
esta guía, especialmente para mis ex-compañeros del Área de Lenguajes y Sistemas
Informáticos de la Universidad de Burgos, para todos mis antiguos alumnos que se
dejaron “engañar” para iniciar esta aventura y para Ignacio Cruzado cuyo trabajo en
estos últimos meses ha dotado de contenido y forma a la versión de la guía que hoy se
hace realidad.
Salamanca, 13 de octubre de 1999
Francisco José García Peñalvo
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 12 de 189
PREFACIO
Cuando hace dos cursos el profesor Francisco José García Peñalvo nos propuso redactar
el esbozo de un tutorial sobre Java, de carácter voluntario, y aunque los alumnos
siempre somos reacios a una carga de trabajo sin compensación en la calificación,
sorprendentemente, los alumnos aceptamos. La continua apuesta de "Fran" por su
alumnado, y la confianza que en nosotros depositó, realmente nos estimuló a dar todo lo
mejor de nosotros.
Aunque desgraciadamente aquel año no toda la clase pudiera superar la asignatura,
sobre todo por la carga docente, pocas voces he oído en desacuerdo con las novedosas
formas docentes que aquel año se experimentaron.
Aunque la redacción de la primera versión, hecha por diferentes grupos de trabajo, era
muy vaga, heterogénea y estaba llena de erratas, ha sido el pilar de este tutorial, tanto
como esquema de temas a tratar, como bibliografía a manejar.
En la redacción de este tutorial se ha pretendido abarcar el mayor número de aspectos
posibles de la gran variedad de temas que rodean a Java. Espero no haber perdido nunca
de vista que este tutorial debe de servir tanto a expertos informáticos como a
programadores de cualquier tipo que, aun no teniendo idea de programación orientada a
objetos, tengan interés en Java.
Así mismo espero que la bibliografía aportada sea suficiente para aquellos que hayáis
quedado prendados de la potencia de este nuevo lenguaje de programación.
Debo decir que mientras desarrollaba este tutorial me ha impresionado la potencia de
Java por tres motivos principales:
1. Sus amplias bibliotecas multiplataforma.
2. La posibilidad de desarrollar aplicaciones que funcionen en Internet mediante
navegadores (applets).
3. Todo ello con un lenguaje orientado a objeto sencillo pero potente.
Esperemos que pronto los problemas de incompatibilidad entre Microsoft Explorer y
Netscape Navigator se solucionen, con lo que se vivirá un futuro lleno de esplendor para
Java.
CONTENIDOS
Este tutorial ha sido dividido en una serie de temas (cada uno de ellos compuesto de
varios apartados) para una más fácil consulta y una mayor claridad en cuánto a qué se
está intentando explicar.
A continuación se detalla de una forma general los contenidos de cada uno de los
apartados.
En el primer tema "I. Introauccion" se intenta acercar al lector el mundo Java desde una
perspectiva global; su historia, sus características principales y una comparativa con
otros lenguajes orientados a objeto, para que el lector pueda juzgar si le interesa
aprender Java y para que vaya vislumbrando en qué puntos le va a interesar profundizar.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 13 de 189
En un primer apartado se introducen todos los conceptos necesarios para poder entender
un lenguaje de programación orientado a objeto, como es Java. Este apartado debe ser
de especial interés para todos aquellos lectores que no hayan desarrollado jamás
programas en un lenguaje orientado a objeto, y debe facilitar la comprensión de muchos
conceptos básicos para un mejor entendimiento del resto del tutorial.
El segundo tema "II. Lenguaie" define todos los conceptos básicos y sintaxis del
lenguaje Java; las estructuras que utiliza, su sintaxis, sus sistemas de control...
Los cuatro primeros apartados de este tema son fundamentales para comprender
cualquier fragmento de código Java, y aunque sencillos son similares a los de cualquier
otro lenguaje de programación.
Los temas cinco, seis y siete introducen los aspectos orientados a objeto del lenguaje
Java, comenzando desde los más sencillos como son los objetos y las clases hasta los
más complejos como pueden ser la herencia y el polimorfismo.
Entre los apartados ocho y once se comentan diversos aspectos propios del lenguaje
Java, que dotan a los programas de una mayor potencia como son las excepciones, los
threaas, las interfaces y los paquetes.
Por último en el apartado doce se explican los fundamentos sobre la construcción de
programas Java, aplicaciones que se pueden construir y diversos aspectos referentes a
ellas.
El tercer tema "III. Bibliotecas ae la API ae Java" trata, de una forma global, todas las
bibliotecas de la API de Java que servirán para dotar a los programas de una gran
potencia con multitud de clases e interfaces estándar ya programadas y distribuidas por
Sun.
Además, en un par de apartados se explican las gestiones de las cadenas y de los flujos
de entrada/salida que hace Java. Estas acciones se realizan de forma sensiblemente
diferente a la de otros lenguajes de programación, como por ejemplo C o C++.
En el cuarto tema "IJ. Bibliotecas graficas", se explican las dos bibliotecas que Java
incorpora para desarrollar interfaces gráficas de usuario: AWT y la nueva Swing.
En el quinto tema "J. Java e Internet", se explica la potencia de Java para el desarrollo
de aplicaciones en red, así como el paquete iava.net. el cual da soporte a un montón de
operaciones para el diálogo de diversas aplicaciones de red con aspectos como los
sockets.
En el sexto tema "JI. Applets" se explica el fundamento de este tipo de aplicaciones
especialmente diseñadas para su uso en Internet. Son características de Java y le aportan
una potencia inusitada para el desarrollo de aplicaciones para Internet. Además en este
tema se acompañan una serie de ejemplos para intentar aclarar el desarrollo y
funcionamiento de este tipo de aplicaciones.
Por último al tutorial se le adjuntan una serie de apéndices que sirvan como breves
reseñas sobre diferentes aspectos de Java que por una u otra cuestión se ha decidido que
vayan aparte de lo que es el bloque del lenguaje.
Así en el primer apéndice "Apenaice I. JDK", se explica en detalle el funcionamiento
del JDK, herramienta que distribuye Sun para el desarrollo de aplicaciones Java.
En el segundo apéndice "Apenaice II. Herramientas ae aesarrollo", se comentan las
diferentes herramientas disponibles en el mercado para desarrollar aplicaciones Java,
depurarlas y probarlas.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 14 de 189
En un tercer apéndice "Apenaice III. Metoaos Nativos" se explica mediante un ejemplo
de cómo Java es capaz de utilizar código de aplicaciones escritas en otros lenguajes de
programación.
En el cuarto apéndice "Apenaice IJ. Guia ae referencia ae Java a C¹¹" se explican las
similitudes y diferencias entre estos dos lenguajes de programación, dado que Java es
un lenguaje derivado de C++, pero con notables diferencias respecto a su predecesor.
Este apéndice puede ser fundamental para aquellos programadores que proviniendo de
C++ quieran conocer el lenguaje Java, ya que su similitud sintáctica es, en muchos
casos, engañosa.
En el último apéndice "Apenaice J. Guia ae referencia ael lenguaie", se explican, a
modo de resumen, las características fundamentales del lenguaje Java
AGRADECIMIENTOS
Me gustaría aprovechar este momento para felicitar a Francisco José García Peñalvo por
el esfuerzo que hace por una docencia más moderna y atractiva, así como la confianza
que deposita en su alumnado, y por el agradable clima de trabajo que ha creado para la
realización de este tutorial.
Así mismo me gustaría agradecer al Área de Lenguajes y Sistemas Informáticos de la
Universidad de Burgos la confianza depositada en mi así como toda la documentación
bibliográfica que me han facilitado.
Por último me gustaría agradecer muy especialmente a Amelia Pajares Rojo su
colaboración espontánea en este proyecto, consiguiendo así un tutorial mucho más claro
y legible.
Espero que este tutorial realmente os agrade a todos.
Ignacio Cruzado Nuño
Burgos, Septiembre de 1999
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 15 de 189
TEMA I: INTRODUCCIÓN

Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 16 de 189
I.1. INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS
A. PROGRAMACIÓN ORIENTADA A OBJETOS
La orientación a objetos es un paradigma de programación que facilita la creación de
software de calidad por sus factores que potencian el mantenimiento, la extensión y la
reutilización del software generado bajo este paradigma.
La programación orientada a objetos trata de amoldarse al modo de pensar del hombre y
no al de la máquina. Esto es posible gracias a la forma racional con la que se manejan
las abstracciones que representan las entidades del dominio del problema, y a
propiedades como la jerarquía o el encapsulamiento.
El elemento básico de este paradigma no es la función (elemento básico de la
programación estructurada), sino un ente denominado objeto. Un objeto es la
representación de un concepto para un programa, y contiene toda la información
necesaria para abstraer dicho concepto: los datos que describen su estado y las
operaciones que pueden modificar dicho estado, y determinan las capacidades del
objeto.
Java incorpora el uso de la orientación a objetos como uno de los pilares básicos de su
lenguaje.
B. LOS OBJETOS
Podemos definir objeto como el "encapsulamiento de un conjunto de operaciones
(métodos) que pueden ser invocados externamente, y de un estado que recuerda el
efecto de los servicios". }Piattini et al., 1996].
Un objeto además de un estado interno, presenta una interfaz para poder interactuar con
el exterior. Es por esto por lo que se dice que en la programación orientada a objetos "se
unen datos y procesos", y no como en su predecesora, la programación estructurada, en
la que estaban separados en forma de variables y funciones.
Un objeto consta de:
Œ Tiempo de vida: La duración de un objeto en un programa siempre está limitada en
el tiempo. La mayoría de los objetos sólo existen durante una parte de la ejecución
del programa. Los objetos son creados mediante un mecanismo denominado
instanciacion, y cuando dejan de existir se dice que son aestruiaos.
Œ Estado: Todo objeto posee un estado, definido por sus atributos. Con él se definen
las propiedades del objeto, y el estado en que se encuentra en un momento
determinado de su existencia.
ΠComportamiento: Todo objeto ha de presentar una interfaz, definida por sus
metoaos, para que el resto de objetos que componen los programas puedan
interactuar con él.
El equivalente de un obieto en el paradigma estructurado sería una variable. Así mismo
la instanciacion ae obietos equivaldría a la aeclaracion ae variables, y el tiempo ae viaa
ae un obieto al ambito ae una variable.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 17 de 189
C. LAS CLASES
Las clases son abstracciones que representan a un conjunto de objetos con un
comportamiento e interfaz común.
Podemos definir una clase como "un conjunto de cosas (físicas o abstractas) que tienen
el mismo comportamiento y características... Es la implementación de un tipo de objeto
(considerando los objetos como instancias de las clases)". }Piattini et al., 1996].
Una clase no es más que una plantilla para la creación de objetos. Cuando se crea un
objeto (instanciacion) se ha de especificar de qué clase es el objeto instanciado, para
que el compilador comprenda las características del objeto.
Las clases presentan el estado de los objetos a los que representan mediante variables
denominadas atributos. Cuando se instancia un objeto el compilador crea en la memoria
dinámica un espacio para tantas variables como atributos tenga la clase a la que
pertenece el objeto.
Los metoaos son las funciones mediante las que las clases representan el
comportamiento de los objetos. En dichos métodos se modifican los valores de los
atributos del objeto, y representan las capacidades del objeto (en muchos textos se les
denomina servicios).
Desde el punto de vista de la programación estructurada, una clase se asemejaría a un
módulo, los atributos a las variables globales de dicho módulo, y los métodos a las
funciones del módulo.
D. MODELO DE OBJETOS
Existen una serie de principios fundamentales para comprender cómo se modeliza la
realidad al crear un programa bajo el paradigma de la orientación a objetos. Estos
principios son: la abstracción, el encapsulamiento, la modularidad, la jerarquía, el paso
de mensajes y el poliforfismo.
a.) Principio de Abstracción
Mediante la abstracción la mente humana modeliza la realidad en forma de objetos. Para
ello busca parecidos entre la realidad y la posible implementación de obietos ael
programa que simulen el funcionamiento de los obietos reales.
Los seres humanos no pensamos en las cosas como un conjunto de cosas menores; por
ejemplo, no vemos un cuerpo humano como un conjunto de células. Los humanos
entendemos la realidad como objetos con comportamientos bien definidos. No
necesitamos conocer los detalles de porqué ni cómo funcionan las cosas; simplemente
solicitamos determinadas acciones en espera de una respuesta; cuando una persona
desea desplazarse, su cuerpo le responde comenzando a caminar.
Pero la abstracción humana se gestiona de una manera jerárquica, dividiendo
sucesivamente sistemas complejos en conjuntos de subsistemas, para así entender más
fácilmente la realidad. Esta es la forma de pensar que la orientación a objeto intenta
cubrir.
b.) Principio de Encapsulamiento
El encapsulamiento permite a los objetos elegir qué información es publicada y qué
información es ocultada al resto de los objetos. Para ello los objetos suelen presentar sus
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 18 de 189
métodos como interfaces públicas y sus atributos como datos privados e inaccesibles
desde otros objetos.
Para permitir que otros objetos consulten o modifiquen los atributos de los objetos, las
clases suelen presentar métodos de acceso. De esta manera el acceso a los datos de los
objetos es controlado por el programador, evitando efectos laterales no deseados.
Con el encapsulado de los datos se consigue que las personas que utilicen un objeto sólo
tengan que comprender su interfaz, olvidándose de cómo está implementada, y en
definitiva, reduciendo la complejidad de utilización.
c.) Principio de Modularidad
Mediante la modularidad, se propone al programador dividir su aplicación en varios
módulos diferentes (ya sea en forma de clases, paquetes o bibliotecas), cada uno de ellos
con un sentido propio.
Esta fragmentación disminuye el grado de dificultad del problema al que da respuesta el
programa, pues se afronta el problema como un conjunto de problemas de menor
dificultad, además de facilitar la comprensión del programa.
d.) Principio de Jerarquía
La mayoría de nosotros ve de manera natural nuestro mundo como objetos que se
relacionan entre sí de una manera jerárquica. Por ejemplo, un perro es un mamífero, y
los mamíferos son animales, y los animales seres vivos...
Del mismo modo, las distintas clases de un programa se organizan mediante la
ierarquia. La representación de dicha organización da lugar a los denominados arboles
ae herencia:
Imagen 1. Eiemplo ae arbol ae herencia
Mediante la herencia una clase hiia puede tomar determinadas propiedades de una clase
paare. Así se simplifican los diseños y se evita la duplicación de código al no tener que
volver a codificar métodos ya implementados.
Al acto de tomar propiedades de una clase padre se denomina hereaar.
e.) Principio del Paso de Mensajes
Mediante el denominado paso ae mensaies, un objeto puede solicitar de otro objeto que
realice una acción determinada o que modifique su estado. El paso de mensajes se suele
implementar como llamadas a los métodos de otros objetos.
Desde el punto de vista de la programación estructurada, esto correspondería con la
llamada a funciones.
Clase Nieta1 Clase Nieta2
Clase Hija1
Clase Nieta3
Clase Hija2
Clase Padre
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 19 de 189
f.) Principio de Polimorfismo
Polimorfismo quiere decir "un objeto y muchas formas". Esta propiedad permite que un
objeto presente diferentes comportamientos en función del contexto en que se
encuentre. Por ejemplo un método puede presentar diferentes implementaciones en
función de los argumentos que recibe, recibir diferentes números de parámetros para
realizar una misma operación, y realizar diferentes acciones dependiendo del nivel de
abstracción en que sea llamado.
E. RELACIONES ENTRE OBJETOS
Durante la ejecución de un programa, los diversos objetos que lo componen han de
interactuar entre sí para lograr una serie de objetivos comunes.
Existen varios tipos de relaciones que pueden unir a los diferentes objetos, pero entre
ellas destacan las relaciones de: asociación, todo/parte, y generalización/especialización.
a.) Relaciones de Asociación
Serían relaciones generales, en las que un objeto realiza llamadas a los servicios
(métodos) de otro, interactuando de esta forma con él.
Representan las relaciones con menos riqueza semántica.
b.) Relaciones de Todo/Parte
Muchas veces una determinada entidad existe como conjunción de otras entidades,
como un conglomerado de ellas. La orientación al objeto recoge este tipo de relaciones
como dos conceptos; la agregación y la composición.
En este tipo de relaciones un obieto componente se integra en un obieto compuesto. La
diferencia entre agregación y composición es que mientras que la composición se
entiende que dura durante toda la vida del objeto componedor, en la agregación no tiene
por qué ser así.
Esto se puede implementar como un objeto (obieto compuesto) que cuenta entre sus
atributos con otro objeto distinto (obieto componente).
c.) Relaciones de Generalización/Especialización
A veces sucede que dos clases tiene muchas de sus partes en común, lo que
normalmente se abstrae en la creación de una tercera clase (paare de las dos) que reúne
todas sus características comunes.
El ejemplo más extendido de este tipo de relaciones es la herencia, propiedad por la que
una clase (clase hiia) recoge aquellos métodos y atributos que una segunda clase (clase
paare) ha especificado como "heredables".
Este tipo de relaciones es característico de la programación orientada a objetos.
En realidad, la generalización y la especialización son diferentes perspectivas del mismo
concepto, la generalización es una perspectiva ascendente (bottom-up), mientras que la
especialización es una perspectiva descendente (top-aown).
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 20 de 189
Para más información sobre el modelo de objetos en la programación avanzada, y las
relaciones entre objetos véase }García, 1998] o para una información más detallada
consulte }Booch, 1996].
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 21 de 189
I.2. HISTORIA DE JAVA
A. ¿POR QUÉ SE DISEÑÓ JAVA?
Los lenguajes de programación C y Fortran se han utilizado para diseñar algunos de los
sistemas más complejos en lenguajes de programación estructurada, creciendo hasta
formar complicados procedimientos. De ahí provienen términos como “código de
espagueti” o “canguros” referentes a programas con múltiples saltos y un control de
flujo difícilmente trazable.
No sólo se necesitaba un lenguaje de programación para tratar esta complejidad, sino un
nuevo estilo de programación. Este cambio de paradigma de la programación
estructurada a la programación orientada a objetos, comenzó hace 30 años con un
lenguaje llamado Simula67.
El lenguaje C++ fue un intento de tomar estos principios y emplearlos dentro de las
restricciones de C. Todos los compiladores de C++ eran capaces de compilar programas
de C sin clases, es decir, un lenguaje capaz de interpretar dos estilos diferentes de
programación. Esta compatibilidad ("hacia atras") que habitualmente se vende como
una característica de C++ es precisamente su punto más débil. No es necesario utilizar
un diseño orientado a objetos para programar en C++, razón por la que muchas veces
las aplicaciones en este lenguaje no son realmente orientadas al objeto, perdiendo así los
beneficios que este paradigma aporta.
Así Java utiliza convenciones casi idénticas para declaración de variables, paso de
parámetros, y demás, pero sólo considera las partes de C++ que no estaban ya en C.
Las principales características que Java no hereda de C++ son:
Œ Punteros: Las direcciones de memoria son la característica más poderosa de C++. El
inadecuado uso de los punteros provoca la mayoría de los errores de colisión de
memoria, errores muy difíciles de detectar. Además, casi todos los virus que se han
escrito aprovechan la capacidad de un programa para acceder a la memoria volátil
(RAM) utilizando punteros. En Java, no existen punteros, evitando el acceso directo
a la memoria volátil.
Œ Variables globales: Con ellas cualquier función puede producir efectos laterales, e
incluso se pueden producir fallos catastróficos cuando algún otro método cambia el
estado de la variable global necesaria para la realización de otros procesos. En Java
lo único global es el nombre de las clases.
Œ goto: Manera rápida de arreglar un programa sin estructurar el código. Java no tiene
ninguna sentencia goto. Sin embargo Java tiene las sentencias break y continue que
cubren los casos importantes de goto.
Œ Asignación de memoria: La función malloc de C, asigna un número especificado de
bytes de memoria devolviendo la dirección de ese bloque. La función free devuelve
un bloque asignado al sistema para que lo utilice. Si se olvida de llamar a free para
liberar un bloque de memoria, se están limitando los recursos del sistema,
ralentizando progresivamente los programas. Si por el contrario se hace un free
sobre un puntero ya liberado, puede ocurrir cualquier cosa. Más tarde C++ añadió
new y aelete, que se usan de forma similar, siendo todavía el programador, el
responsable de liberar el espacio de memoria. Java no tiene funciones malloc ni free.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 22 de 189
Se utiliza el operador new para asignar un espacio de memoria a un objeto en el
monticulo de memoria. Con new no se obtiene una dirección de memoria sino un
descriptor al objeto del monticulo. La memoria real asignada a ese objeto se puede
mover a la vez que el programa se ejecuta, pero sin tener que preocuparse de ello.
Cuando no tenga ninguna referencia de ningún objeto, la memoria ocupada estará
disponible para que la reutilice el resto del sistema sin tener que llamar a free o
aelete. A esto se le llama recogiaa ae basura. El recolector de basura se ejecuta
siempre que el sistema esté libre, o cuando una asignación solicitada no encuentre
asignación suficiente.
Œ Conversión de tipos insegura: Los moldeados de tipo (tvpe casting) son un
mecanismo poderoso de C y C++ que permite cambiar el tipo de un puntero. Esto
requiere extremada precaución puesto que no hay nada previsto para detectar si la
conversión es correcta en tiempo de ejecución. En Java se puede hacer una
comprobación en tiempo de ejecución de la compatibilidad de tipos y emitir una
excepción cuando falla.
B. COMIENZOS
Java fue diseñado en 1990 por James Gosling, de Sun Microsystems, como software
para dispositivos electrónicos de consumo. Curiosamente, todo este lenguaje fue
diseñado antes de que diese comienzo la era World Wide Web, puesto que fue diseñado
para dispositivos electrónicos como calculadoras, microondas y la televisión interactiva.
Imagen 2. Logotipo ae la empresa Sun Microsvstems
En los primeros años de la década de los noventa, Sun Microsystems decidió intentar
introducirse en el mercado de la electrónica de consumo y desarrollar programas para
pequeños dispositivos electrónicos. Tras unos comienzos dudosos, Sun decidió crear
una filial, denominada FirstPerson Inc., para dar margen de maniobra al equipo
responsable del proyecto.
Inicialmente Java se llamó Oak (roble en inglés), aunque tuvo que cambiar de
denominación, debido a que dicho nombre ya estaba registrado por otra empresa. Se
dice este nombre se le puso debido a la existencia de tal árbol en los alrededores del
lugar de trabajo de los promotores del lenguaje.
Tres de las principales razones que llevaron a crear Java son:
1. Creciente necesidad de interfaces mucho más cómodas e intuitivas que los sistemas
de ventanas que proliferaban hasta el momento.
2. Fiabilidad del código y facilidad de desarrollo. Gosling observó que muchas de las
características que ofrecían C o C++ aumentaban de forma alarmante el gran coste
de pruebas y depuración. Por ello en los sus ratos libres creó un lenguaje de
programación donde intentaba solucionar los fallos que encontraba en C++.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 23 de 189
3. Enorme diversidad de controladores electrónicos. Los dispositivos electrónicos se
controlan mediante la utilización de microprocesadores de bajo precio y reducidas
prestaciones, que varían cada poco tiempo y que utilizan diversos conjuntos de
instrucciones. Java permite escribir un código común para todos los dispositivos.
Por todo ello, en lugar de tratar únicamente de optimizar las técnicas de desarrollo y dar
por sentada la utilización de C o C++, el equipo de Gosling se planteó que tal vez los
lenguajes existentes eran demasiado complicados como para conseguir reducir de forma
apreciable la complejidad de desarrollo asociada a ese campo. Por este motivo, su
primera propuesta fue idear un nuevo lenguaje de programación lo más sencillo posible,
con el objeto de que se pudiese adaptar con facilidad a cualquier entorno de ejecución.
Basándose en el conocimiento y estudio de gran cantidad de lenguajes, este grupo
decidió recoger las características esenciales que debía tener un lenguaje de
programación moderno y potente, pero eliminando todas aquellas funciones que no eran
absolutamente imprescindibles.
Para más información véase }Cuenca, 1997].
C. PRIMEROS PROYECTOS EN QUE SE APLICÓ JAVA
El proyecto Green fue el primero en el que se aplicó Java, y consistía en un sistema de
control completo de los aparatos electrónicos y el entorno de un hogar. Con este fin se
construyó un ordenador experimental denominado *7 (Star Seven). El sistema
presentaba una interfaz basada en la representación de la casa de forma animada y el
control se llevaba a cabo mediante una pantalla sensible al tacto. En el sistema aparecía
ya Duke, la actual mascota de Java.
Imagen 3. Icono ae Duke. la mascota ae Java
Más tarde Java se aplicó a otro proyecto denominado VOD (Video On Demand) en el
que se empleaba como interfaz para la televisión interactiva que se pensaba iba a ser el
principal campo de aplicación de Java. Ninguno de estos proyectos se convirtió nunca
en un sistema comercial, pero fueron desarrollados enteramente en un Java primitivo.
Una vez que en Sun se dieron cuenta de que a corto plazo la televisión interactiva no iba
a ser un gran éxito, instaron a FirstPerson a desarrollar nuevas estrategias que
produjeran beneficios. Entre ellas se encontraba la aplicación de Java a Internet, la cual
no se consideró productiva en ese momento.
Para más información véase }Froufe, 1997].
D. RESURGIMIENTO DE JAVA
Aunque muchas de las fuentes consultadas señalan que Java no llegó a caer en un
olvido, lo cierto es que tuvo que ser Bill Joy (cofundador de Sun y uno de los
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 24 de 189
desarrolladores principales del sistema operativo Unix de Berckley) el que sacó a Java
del letargo en que estaba sumido. Joy juzgó que Internet podría llegar a ser el campo
adecuado para disputar a Microsoft su primacía en el terreno del software, y vio en Oak
el instrumento idóneo para llevar a cabo estos planes.
Para poder presentarlo en sociedad se tuvo que modificar el nombre de este lenguaje de
programación y se tuvo que realizar una serie de modificaciones de diseño para poderlo
adaptar al propósito mencionado. Así Java fue presentado en sociedad en agosto de
1995.
Algunas de las razones que llevaron a Bill Joy a pensar que Java podría llegar a ser
rentable son:
Œ Java es un lenguaje orientado a objetos: Esto es lo que facilita abordar la resolución
de cualquier tipo de problema.
ΠEs un lenguaje sencillo, aunque sin duda potente.
Œ La ejecución del código Java es segura y fiable: Los programas no acceden
directamente a la memoria del ordenador, siendo imposible que un programa escrito
en Java pueda acceder a los recursos del ordenador sin que esta operación le sea
permitida de forma explícita. De este modo, los datos del usuario quedan a salvo de
la existencia de virus escritos en Java. La ejecución segura y controlada del código
Java es una característica única, que no puede encontrarse en ninguna otra
tecnología.
ΠEs totalmente multiplataforma: Es un lenguaje sencillo, por lo que el entorno
necesario para su ejecución es de pequeño tamaño y puede adaptarse incluso al
interior de un navegador.
Las consecuencias de la utilización de Java junto a la expansión universal de Internet
todavía están comenzando a vislumbrarse.
Para más información véase }Froufe, 1997].
E. FUTURO DE JAVA
Existen muchas críticas a Java debido a su lenta velocidad de ejecución,
aproximadamente unas 20 veces más lento que un programa en lenguaje C. Sun está
trabajando intensamente en crear versiones de Java con una velocidad mayor.
El problema fundamental de Java es que utiliza una representación intermedia
denominada coaigo ae bvte para solventar los problemas de portabilidad. Los coaigos
ae bvte posteriormente se tendrán que transformar en código máquina en cada máquina
en que son utilizados, lo que ralentiza considerablemente el proceso de ejecución.
La solución que se deriva de esto parece bastante obvia: fabricar ordenadores capaces
de comprender directamente los códigos de byte. Éstas serían unas máquinas que
utilizaran Java como sistema operativo y que no requerirían en principio de disco duro
porque obtendrían sus recursos de la red.
A los ordenadores que utilizan Java como sistema operativo se les llama Network
Computer, WebPC o WebTop. La primera gran empresa que ha apostado por este tipo
de máquinas ha sido Oracle, que en enero de 1996 presentó en Japón su primer NC
(Network Computer), basado en un procesador RISC con 8 Megabytes de RAM. Tras
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 25 de 189
Oracle, han sido compañías del tamaño de Sun, Apple e IBM las que han anunciado
desarrollos similares.
La principal empresa en el mundo del software, Microsoft, que en los comienzos de
Java no estaba a favor de su utilización, ha licenciado Java, lo ha incluido en Internet
Explorer (versión 3.0 y posteriores), y ha lanzado un entorno de desarrollo para Java,
que se denomina Visual J++.
El único problema aparente es la seguridad para que Java se pueda utilizar para
transacciones críticas. Sun va a apostar por firmas digitales, que serán clave en el
desarrollo no sólo de Java, sino de Internet.
Para más información véase }Framiñán, 1997].
F. ESPECULACIÓN SOBRE EL FUTURO DE JAVA
En opinión de los redactores de este tutorial, Java es una plataforma que le falta
madurar, pero que a buen seguro lo va a hacer. La apuesta realizada por empresas con
mucho peso específico ha sido tan grande que va a dar un impulso a Java que no le
permitirá caer
Además, el parque de productos (entornos de desarrollo, bibliotecas, elementos de
conectividad...) ya disponible en la actualidad es tan amplio que es improbable que se
quede en nada.
Por otra parte, la relación simbiótica que tiene con Internet (y por derivación con las
Intranets) es un punto a favor de Java de muy difícil refutación.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 26 de 189
I.3. CARACTERÍSTICAS DE JAVA
A. INTRODUCCIÓN
No es arriesgado afirmar que Java supone un significativo avance en el mundo de los
entornos software, y esto viene avalado por tres elementos claves que diferencian a este
lenguaje desde un punto de vista tecnológico:
Œ Es un lenguaje de programación que ofrece la potencia del diseño orientado a
objetos con una sintaxis fácilmente accesible y un entorno robusto y agradable.
ΠProporciona un conjunto de clases potente y flexible.
Œ Pone al alcance de cualquiera la utilización de aplicaciones que se pueden incluir
directamente en páginas Web (aplicaciones denominadas applets).
Java aporta a la Web una interactividad que se había buscado durante mucho tiempo
entre usuario y aplicación.
A lo largo de este apartado se estudian en detalle las principales características de Java.
B. POTENTE
a.) Orientación a objetos
En este aspecto Java fue diseñado partiendo de cero, no siendo derivado de otro
lenguaje anterior y no tiene compatibilidad con ninguno de ellos.
En Java el concepto de objeto resulta sencillo y fácil de ampliar. Además se conservan
elementos “no objetos”, como números, caracteres y otros tipos de datos simples.
b.) Riqueza semántica
Pese a su simpleza se ha conseguido un considerable potencial, y aunque cada tarea se
puede realizar de un número reducido de formas, se ha conseguido un gran potencial de
expresión e innovación desde el punto de vista del programador.
c.) Robusto
Java verifica su código al mismo tiempo que lo escribe, y una vez más antes de
ejecutarse, de manera que se consigue un alto margen de codificación sin errores. Se
realiza un descubrimiento de la mayor parte de los errores durante el tiempo de
compilación, ya que Java es estricto en cuanto a tipos y declaraciones, y así lo que es
rigidez y falta de flexibilidad se convierte en eficacia. Respecto a la gestión de memoria,
Java libera al programador del compromiso de tener que controlar especialmente la
asignación que de ésta hace a sus necesidades específicas. Este lenguaje posee una
gestión avanzada de memoria llamada gestión de basura, y un manejo de excepciones
orientado a objetos integrados. Estos elementos realizarán muchas tareas antes tediosas
a la vez que obligadas para el programador.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 27 de 189
d.) Modelo de objeto rico
Existen varias clases que contienen las abstracciones básicas para facilitar a los
programas una gran capacidad de representación. Para ello se contará con un conjunto
de clases comunes que pueden crecer para admitir todas las necesidades del
programador.
Además la biblioteca de clases de Java proporciona un conjunto único de protocolos de
Internet.
El conjunto de clases más complicado de Java son sus paquetes gráficos AWT (Abstract
Winaow Toolkit) y Swing. Estos paquetes implementan componentes de una interfaz de
usuario gráfica básica común a todos los ordenadores personales modernos.
C. SIMPLE
a.) Fácil aprendizaje
El único requerimiento para aprender Java es tener una comprensión de los conceptos
básicos de la programación orientada a objetos. Así se ha creado un lenguaje simple
(aunque eficaz y expresivo) pudiendo mostrarse cualquier planteamiento por parte del
programador sin que las interioridades del sistema subyacente sean desveladas.
Java es más complejo que un lenguaje simple, pero más sencillo que cualquier otro
entorno de programación. El único obstáculo que se puede presentar es conseguir
comprender la programación orientada a objetos, aspecto que, al ser independiente del
lenguaje, se presenta como insalvable.
b.) Completado con utilidades
El paquete de utilidades de Java viene con un conjunto completo de estructuras de datos
complejas y sus métodos asociados, que serán de inestimable ayuda para implementar
applets y otras aplicaciones más complejas. Se dispone también de estructuras de datos
habituales, como pilas y tablas hash, como clases ya implementadas.
Existirá una interfaz Observer/Observable que permitirá la implementación simple de
objetos dinámicos cuyo estado se visualiza en pantalla.
El JDK (Java Development Kit) suministrado por Sun Microsystems incluye un
compilador, un intérprete de aplicaciones, un depurador en línea de comandos, y un
visualizador de applets entre otros elementos.
D. INTERACTIVO Y ORIENTADO A RED
a.) Interactivo y animado
Uno de los requisitos de Java desde sus inicios fue la posibilidad de crear programas en
red interactivos, por lo que es capaz de hacer varias cosas a la vez sin perder rastro de lo
que debería suceder y cuándo. Para se da soporte a la utilización de múltiples hilos de
programación (multithreaa).
Las aplicaciones de Java permiten situar figuras animadas en las páginas Web, y éstas
pueden concebirse con logotipos animados o con texto que se desplace por la pantalla.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 28 de 189
También pueden tratarse gráficos generados por algún proceso. Estas animaciones
pueden ser interactivas, permitiendo al usuario un control sobre su apariencia.
b.) Arquitectura neutral
Java está diseñado para que un programa escrito en este lenguaje sea ejecutado
correctamente independientemente de la plataforma en la que se esté actuando
(Macintosh, PC, UNIX…). Para conseguir esto utiliza una compilación en una
representación intermedia que recibe el nombre de coaigos ae bvte, que pueden
interpretarse en cualquier sistema operativo con un intérprete de Java. La desventaja de
un sistema de este tipo es el rendimiento; sin embargo, el hecho de que Java fuese
diseñado para funcionar razonablemente bien en microprocesadores de escasa potencia,
unido a la sencillez de traducción a código máquina hacen que Java supere esa
desventaja sin problemas.
c.) Trabajo en red
Java anima las páginas Web y hace posible la incorporación de aplicaciones interactivas
y especializadas. Aporta la posibilidad de distribuir contenidos ejecutables, de manera
que los suministradores de información de la Web pueden crear una página de
hipertexto (pagina Web) con una interacción continuada y compleja en tiempo real; el
contenido ejecutable es transferido literalmente al ordenador del usuario.
Los protocolos básicos para trabajar en Internet están encapsulados en unas cuantas
clases simples. Se incluyen implementaciones ampliables de los protocolos FTP, HTTP,
NNTP y SMTP junto con conectores de red de bajo nivel e interfaces de nombrado.
Esto le permite interactuar con esos servicios de red poderosos sin tener que
comprender realmente los detalles de bajo nivel de esos protocolos. Este lenguaje está
diseñado para cumplir los requisitos de entrega de contenidos interactivos mediante el
uso de applets insertados en sus páginas HTML. Además, las clases de Java admiten
muy bien estos protocolos y formatos. El envío de las clases de Java a través de Internet
se realiza con gran facilidad, ya que existe una interfaz unificada, resolviendo así los
típicos problemas de diferencia de versiones.
Java proporciona un conjunto de clases para tratar con una abstracción de los conectores
de red (sockets) originales de la versión UNIX de Berckley, encapsular la noción de una
dirección de Internet o conectar sockets con flujos de datos de Entrada/Salida.
Con todas estas posibilidades aumenta el dinamismo y competitividad de la Web,
puesto que es capaz de captar el interés del usuario durante largo tiempo y permite a los
programadores convertir la Web en un sistema de entrega de software.
d.) Applets
Una applet (miniaplicación) es un pequeño programa en Java transferido
dinámicamente a través de Internet. Presentan un comportamiento inteligente, pudiendo
reaccionar a la entrada de un usuario y cambiar de forma dinámica. Sin embargo, la
verdadera novedad es el gran potencial que Java proporciona en este aspecto, haciendo
posible que los programadores ejerzan un control sobre los programas ejecutables de
Java que no es posible encontrar en otros lenguajes.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 29 de 189
E. Y MUCHO MÁS
a.) Seguridad
Existe una preocupación lógica en Internet por el tema de la seguridad: virus, caballos
de Troya, y programas similares navegan de forma usual por la red, constituyendo una
amenaza palpable. Java ha sido diseñado poniendo un énfasis especial en el tema de la
seguridad, y se ha conseguido lograr cierta inmunidad en el aspecto de que un programa
realizado en Java no puede realizar llamadas a funciones globales ni acceder a recursos
arbitrarios del sistema, por lo que el control sobre los programas ejecutables no es
equiparable a otros lenguajes.
Los niveles de seguridad que presenta son:
Œ Fuertes restricciones al acceso a memoria, como son la eliminación de punteros
aritméticos y de operadores ilegales de transmisión.
Œ Rutina de verificación de los coaigos ae bvte que asegura que no se viole ninguna
construcción del lenguaje.
Œ Verificación del nombre de clase y de restricciones de acceso durante la carga.
ΠSistema de seguridad de la interfaz que refuerza las medidas de seguridad en
muchos niveles.
En futuras versiones se prevé contar también con encriptación y técnicas similares.
b.) Lenguaje basado en C++
Java fue desarrollado basándose en C++, pero eliminando rasgos del mismo poco
empleados, optándose por una codificación comprensible. Básicamente, encontramos
las siguientes diferencias con C++:
ΠJava no soporta los tipos struct. union ni punteros.
ΠNo soporta tvpeaef ni raefine.
ΠSe distingue por su forma de manejar ciertos operadores y no permite una
sobrecarga de operadores.
Œ No soporta herencia múltiple.
Œ Java maneja argumentos en la línea de comandos de forma diversa a como lo hacen
C o C++.
ΠTiene una clase String que es parte del paquete iava.lang y se diferencia de la matriz
de caracteres terminada con un nulo que usan C y C++.
Œ Java cuenta con un sistema automático para asignar y liberar memoria, con lo que
no es necesario utilizar las funciones previstas con este fin en C y C++.
c.) Gestión de la Entrada/Salida
En lugar de utilizar primitivas como las de C para trabajar con ficheros, se utlizan
primitivas similares a las de C++, mucho más elegantes, que permiten tratar los
ficheros, sockets, teclado y monitor como flujos de datos.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 30 de 189
De este modo se pueden utilizar dichas primitivas para cualquier operación de
Entrada/Salida.
d.) Diferentes tipos de aplicaciones
En Java podemos crear los siguientes tipos de aplicaciones:
ΠAplicaciones: Se ejecutan sin necesidad de un navegador.
ΠApplets: Se pueden descargar de Internet y se observan en un navegador.
Œ JavaBeans: Componentes software Java, que se puedan incorporar gráficamente a
otros componentes.
ΠJavaScript: Conjunto del lenguaje Java que puede codificarse directamente sobre
cualquier documento HTML
Œ Servlets: Módulos que permiten sustituir o utilizar el lenguaje Java en lugar de
programas CGI (Common Gateway Interface) a la hora de dotar de interactividad a
las páginas Web.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 31 de 189
I.4. COMPARATIVA CON OTROS LENGUAJES DE PROGRAMACIÓN
ORIENTADOS A OBJETO
A. INTRODUCCIÓN
En este apartado se va a comparar Java con otros lenguajes de programación orientados
a objeto.
En principio Java fue diseñado tomando C y C++ como base para la creación de un
nuevo lenguaje con la modificación de todos aquellos aspectos que no eran útiles o
dificultosos para la programación de componentes electrónicos de bajo coste. Para ello
el nuevo lenguaje debía incluir interfaces cómodas, debía ser fiable y fácil de desarrollar
y los programas debían ser portables de un sistema a otro sin ningún tipo de problema.
B. COMPARACIÓN DE LOS TIPOS DE DATOS
a.) Tipos de datos simples (primitivos)
Java es muy parecido a C++ en el juego básico de tipos de datos con algunas pequeñas
modificaciones.
En Java se distingue entre tipos de datos primitivos y clases, aunque existen unas clases
especiales (envoltorios o wrappers) que permiten modificar los tipos de datos
primitivos.
Los tipos de datos primitivos (o simples) pueden ser numéricos, booleanos o caracteres.
b.) Datos numéricos
Hay cuatro tipos numéricos: bvte de 1 byte, short de 2 bytes, int de 4 bytes, y los long
de 8 bytes. El tipo más habitual de los cuatro es el tipo int. El bvte viene a sustituir el
tipo char de C++, ya que Java introduce una interpretación diferente al tipo de datos
char.
Las principales diferencias con C++ son:
Œ No existe un tipo sin signo (unsignea) para los números en Java.
Œ Los tipos numéricos reales son el float (8 bytes) y el aouble (16 bytes).
Œ Los números que utilizan coma flotante (por ejemplo 18.96) son considerados
aouble por defecto, y habrá que realiza un moldeado (casting) explícito para que
sean float.
c.) Caracteres
Los datos carácter en Java se basan en los de C++ que a su vez son heredados de C. Los
caracteres son Unicoae de 2 bytes. Los caracteres Unicoae son valores de 2 bytes sin
signo, con lo que se define obtiene un rango de 65535 caracteres diferentes, que son
suficientes para las los diferentes lenguajes y sistemas de representación del planeta.
El carácter de datos del lenguaje Java proviene del tradicional C. Hay que señalar que
los caracteres en C++ eran de sólo 1 byte, con lo que en Java podremos representar
muchos más caracteres que en C++.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 32 de 189
d.) Datos booleanos
En Java se definen para las variables con valores Verdadero/Falso o Sí/No, en
definitiva, valores bi-estado. Una variable booleana puede tener los valores true
(verdadero) o false (falso). Son parecidos a los de C++, aunque en cualquier caso, y a
diferencia de C++ estas variables no pueden ser convertidas a datos numéricos, y es un
tipo de datos básico.
C. OPERADORES RELACIONALES Y ARITMÉTICOS.
Se permite en Java los mismos operadores que C++, con la variación de ~~~
(desplazamiento sin signo) y la utilización del operador ¹ para la concatenación de
cadenas de caracteres.
D. VECTORES
Los vectores en Java, a diferencia de C++, son una clase de objetos. Un vector es un
objeto real con una representación en tiempo real. Se pueden declarar y almacenar
vectores de cualquier tipo, y almacenar también vectores de vectores para obtener
matrices (vectores con varias dimensiones). En este último aspecto no existe diferencia
con C++.
E. CADENAS
Las cadenas en Java son objetos del lenguaje, no existen seudo-arrays de caracteres
(cadenas) como era el caso de C++. Existen dos tipos de cadenas de objetos:
Las que se obtienen de la clase String, para cadenas de sólo lectura.
Las que se obtienen de la clase StringBuffer para cadenas que se pueden modificar.
Al igual que C++, el compilador de Java entiende que una cadena de caracteres rodeada
de dobles comillas es una cadena, y es iniciada como un objeto de tipo String (en C++
sería como vector de caracteres con el carácter fin de cadena ‘\0’ al final de la misma).
F. OTRAS CARACTERÍSTICAS
a.) Introducción
En este apartado se va a comparar Java con los lenguajes C++ y Smalltalk (primer
lenguaje que presentaba un modelo de objeto).
Característica 1ava Smalltalk C++
Sencillez Sí Sí No
Robustez Sí Sí No
Seguridad Sí Algo No
Interpretado Sí Sí No
Dinamicidad Sí Sí No
Portabilidad Sí Algo No
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 33 de 189
Neutralidad Sí Algo No
Threads Sí No No
Garbage Colection Sí Sí No
Excepciones Sí Sí Algunas
Representación Alta Media Alta
Tabla 1. Comparacion entre Java. SmallTalk v C¹¹
b.) Sencillez
Java tiene una sencillez que no posee C++ aunque sí Smalltalk. Esto es debido a que
una de las razones de la creación de Java es la de obtener un lenguaje parecido a C++
pero reduciendo los errores más comunes de la programación, algo que se logra con
mucho éxito puesto que Java reduce un 50% los errores que se comenten en C++ entre
los que destacan:
Œ Eliminación de la aritmética de punteros y de las referencias.
ΠDesaparecen los registros (struct), heredados del paradigma estructurado.
Œ No se permite ni la definición de tipos (tvpeaef) ni la de macros (raefine).
ΠYa no es necesario liberar memoria (free o aelete).
De todas formas, lo que Java hace, en realidad, es la eliminación de palabras reservadas,
y la utilización de un intérprete bastante pequeño.
c.) Robustez
Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como
en tiempo de ejecución, lo que hace que se detecten errores lo antes posible,
normalmente en el ciclo de desarrollo. Algunas de estas verificaciones que hacen que
Java sea un lenguaje robusto son:
Œ Verificación del coaigo ae bvte.
Œ Gestión de excepciones y errores.
Œ Comprobación de punteros y de límites de vectores.
Se aprecia una clara diferencia con C++ quién no realiza ninguna de estas
verificaciones.
d.) Seguridad
En Java no se permite los accesos ilegales a memoria, algo que sí se permitía en C++.
Esto es algo muy importante puesto que este tipo de problema puede ocasionar la
propagación de virus y otras clases de programas dañinos por la red.
El código Java pasa muchos tests antes de ejecutarse en una máquina. El código se pasa
a través de un verificador de coaigo ae bvte que comprueba el formato de los
fragmentos de código y aplica un probador de teoremas para detectar fragmentos de
código ilegal, código que falsea punteros, viola derechos de acceso sobre objetos o
intenta cambiar el tipo o clase de un objeto.
Algunos de los conocimientos que podemos obtener de los códigos de byte si pasan la
verificación sin generar ningún mensaje de error son:
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 34 de 189
Œ El código no produce desbordamiento de operandos en la pila.
Œ El tipo de los parámetros de todos los códigos de operación es conocido y correcto.
Œ No ha ocurrido ninguna conversión ilegal de datos, tal como convertir enteros en
punteros.
ΠEl acceso a los campos de un objeto se sabe si es legal mediante las palabras
reservadas public, private y protectea.
Œ No hay ningún intento de violar las reglas de acceso y seguridad establecidas.
Por todo esto, y por no permitirlo mediante Java la utilización de métodos de un
programa sin los privilegios del núcleo (kernel) del sistema operativo, la obligación de
autentificación por clave pública para la realización de modificaciones, se considera
Java un lenguaje seguro. Todo esto no lo incorporan ni C++ ni Smalltalk, por lo que
Java es el único de los tres considerable como seguro.
e.) Lenguaje interpretado
Java es un lenguaje que puede ejecutar el código directamente, es decir es un “lenguaje
interpretado”. Esto es una característica que sí que posee Smalltalk, aunque no C++. No
obstante, y aunque en teoría se consumen menos recursos siendo los lenguajes
interpretados, el actual compilador que existe es bastante lento, unas 20 veces menos
rápido que C++. Esto normalmente no es vital para la aplicación ni demasiado
apreciable por el usuario, y además esta diferencia se está reduciendo con los nuevos
compiladores JIT (Just In Time).
f.) Dinamicidad
Para la obtención de un mayor provecho de la tecnología orientada a objetos, Java no
intenta conectar todos los módulos que comprenden una aplicación hasta el tiempo de
ejecución. Esta característica ya es contemplada por Smalltalk, aunque no C++, que
enlaza todos los módulos cuando se compila.
g.) Portabilidad
Un programa Java puede ser ejecutado en diferentes entornos, algo imposible para C++.
h.) Neutralidad
Se dice que Java tiene una arquitectura neutra puesto que compila su código a un
fichero objeto de formato independiente de la arquitectura de la máquina en que se
ejecutará.
Cualquier máquina que tenga el sistema de ejecución (JRE o Java Runtime Enviroment)
puede ejecutar ese código objeto, sin importar en modo alguno la máquina en que ha
sido generado.
Actualmente existen sistemas de ejecución (JRE) para Solaris 2.x, SunOs 4.1.x,
Windows 95, Windows NT, Linux, Irix, Aix, Mac, Apple y probablemente haya grupos
de desarrollo trabajando el portado a otras plataformas.
No es así para C++ y para Smalltalk, donde el código generado podrá ejecutarse
únicamente en la plataforma en la que se generó.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 35 de 189
i.) Threads
Java permite múltiples hilos (multithreaaing) antes de su ejecución y en tiempo de
ejecución. La posibilidad de construir pequeños procesos o piezas independientes de un
gran proceso permite programar de una forma más sencilla y es una herramienta muy
potente que no se ofrece en C++.
j.) Recolección automática de basura ( Garbage colection )
Java modifica completamente la gestión de la memoria que se hace en C/C++. En
C/C++ se utilizan punteros, reservas de memoria (con las ordenes malloc, new, free,
aelete...) y otra serie de elementos que dan lugar a graves errores en tiempo de ejecución
difícilmente depurables.
Java tiene operadores nuevos para reservar memoria para los objetos, pero no existe
ninguna función explícita para liberarla.
La recolección de basura (objetos ya inservibles) es una parte integral de Java durante la
ejecución de sus programas. Una vez que se ha almacenado un objeto en el tiempo de
ejecución, el sistema hace un seguimiento del estado del objeto, y en el momento en que
se detecta que no se va a volver a utilizar ese objeto, el sistema vacía ese espacio de
memoria para un uso futuro.
Esta gestión de la memoria dinámica hace que la programación en Java sea más fácil.
k.) Representación
Uno de los objetivos perseguidos en el desarrollo de Java era la obtención de programas
con interfaces cómodas e intuitivas. Esto también se permite en C++, aunque con unos
métodos más costosos, y en ningún caso con interfaces portables como los que Java
crea.
Tanto en Java como en C++ se logran unas interfaces con una representación mejor que
la que se puede alcanzar con Smalltalk.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 36 de 189
TEMA II: FUNDAMENTOS DEL LENGUAJE
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 37 de 189
II.1. FUNDAMENTOS
A. INTRODUCCIÓN
Java es un lenguaje orientado a objetos, que se deriva en alto grado de C++, de tal forma
que puede ser considerado como un C++ nuevo y modernizado o bien como un C++ al
que se le han amputado elementos heredados del lenguaje estructurado C.
B. TOKENS
Un token es el elemento más pequeño de un programa que es significativo para el
compilador. Estos tokens definen la estructura de Java.
Cuando se compila un programa Java, el compilador analiza el texto, reconoce y
elimina los espacios en blanco y comentarios y extrae tokens individuales. Los tokens
resultantes se compilan, traduciéndolos a código de byte Java, que es independiente del
sistema e interpretable dentro de un entorno Java.
Los códigos de byte se ajustan al sistema de máquina virtual Java, que abstrae las
diferencias entre procesadores a un procesador virtual único.
Los tokens Java pueden subdividirse en cinco categorías: Identificadores, palabras
clave, constantes, operadores y separadores.
a.) Identificadores
Los identificadores son tokens que representan nombres asignables a variables, métodos
y clases para identificarlos de forma única ante el compilador y darles nombres con
sentido para el programador.
Todos los identificadores de Java diferencian entre mayúsculas y minúsculas (Java es
Case Sensitive o Sensible a mavusculas) y deben comenzar con una letra, un
subrayado(_) o símbolo de dólar($). Los caracteres posteriores del identificador pueden
incluir las cifras del 0 al 9. Como nombres de identificadores no se pueden usar palabras
claves de Java.
Además de las restricciones mencionadas existen propuestas de estilo. Es una práctica
estándar de Java denominar:
ΠLas clases: Clase o MiClase.
ΠLas interfaces: Interfaz o MiInterfaz.
Œ Los métodos: metoao() o metoaoLargo().
ΠLas variables: altura o alturaMeaia.
ΠLas constantes: CONSTATE o CONSTANTELARGA.
ΠLos paquetes: iava.paquete.subpaquete.
Sin entrar en más detalle en la siguiente línea de código se puede apreciar la declaración
de una variable entera (int) con su correspondiente identificador:
int alturaMedia;
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 38 de 189
b.) Palabras clave
Las palabras claves son aquellos identificadores reservados por Java para un objetivo
determinado y se usan sólo de la forma limitada y específica. Java tiene un conjunto de
palabras clave más rico que C o que C++, por lo que sí está aprendiendo Java con
conocimientos de C o C++, asegúrese de que presta atención a las palabras clave de
Java.
Las siguientes palabras son palabras reservadas de Java:
abstact boolean break bvte bvvalue
case cast catch char class
const continue aefault ao aouble
else extenas false final finallv
float for future generic goto
if implements import inner instanceof
int interface long native new
null operator outer package private
protectea public rest return short
static super switch svncronicea this
throw throws transient true trv
var voia volatile while
Tabla 2. Palabras reservaaas Java
Las palabras subrayadas son palabras reservadas pero no se utilizan. La definición de
estas palabras clave no se ha revelado, ni se tiene un calendario respecto a cuándo estará
alguna de ellas en la especificación o en alguna de las implementaciones de Java.
c.) Literales y constantes
Los literales son sintaxis para asignar valores a las variables. Cada variables es de un
tipo de datos concreto, y dichos tipos de datos tienen sus propios literales.
Mediante determinados modificadores (static y final) podremos crear variables
constantes, que no modifican su valor durante la ejecución de un programa. Las
constantes pueden ser numéricas, booleanas, caracteres (Unicode) o cadenas (String).
Las cadenas, que contienen múltiples caracteres, aún se consideran constantes, aunque
están implementadas en Java como objetos.
Veamos un ejemplo de constante declarada por el usuario:
final static int ALTURA_MAXIMA = 200;
Se puede observar que utilizamos final static, para que la variable sea total y
absolutamente invariable.
d.) Operadores
Conocidos también como operandos, indican una evaluación o computación para ser
realizada en objetos o datos, y en definitiva sobre identificadores o constantes. Los
operadores admitidos por Java son:
¹ ´ · ¹¹ º
~~~ - ~ -
& . ' && ··
·· [ / [[
~~ ¹ ´ { º
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 39 de 189
' ~~~ ' (
& · ' ) [
~ ?'' / ~~
Tabla 3. Operaaores Java
Así por ejemplo el siguiente fragmento de código incrementa el valor de una variable en
dos unidades, mediante la utilización del operador aritmético ¹ que se utiliza para la
suma:
int miNumero=0;
miNumero = miNumero + 2;
En el apartado "II.3 Operaaores" de este tutorial aprenderemos que en Java hay formas
más sencillas de hacer esto mismo, y estudiaremos el significado de cada uno de estos
operadores.
e. Separadores
Se usan para informar al compilador de Java de cómo están agrupadas las cosas en el
código.
Los separadores admitidos por Java son: { } . . ,
f. Comentarios y espacios en blanco
El compilador de Java reconoce y elimina los espacios en blanco, tabuladores, retornos
de carro y comentarios durante el análisis del código fuente.
Los comentarios se pueden presentar en tres formatos distintos:
Formato Uso
/*comentario*/ Se ignoran todos los caracteres entre /* */. Proviene del C
//comentario Se ignoran todos los caracteres detrás de // hasta el fin de línea. Proviene del C++
/**comentario*/ Lo mismo que /* */ pero se podrán utilizar para documentación automática.
Tabla 4. Formatos ae comentarios Java
Por ejemplo la siguiente línea de código presenta un comentario:
int alturaMinima = 150; // No menos de 150 centímetros
C. EXPRESIONES
Los operadores, variables y las llamadas a métodos pueden ser combinadas en
secuencias conocidas como expresiones. El comportamiento real de un programa Java
se logra a través de expresiones, que se agrupan para crear sentencias.
Una expresión es una serie de variables, operadores y llamadas a métodos (construida
conforme a la sintaxis del lenguaje) que se evalúa a un único valor.
Entre otras cosas, las expresiones son utilizadas para realizar cálculos, para asignar
valores a variables, y para ayudar a controlar la ejecución del flujo del programa. La
tarea de una expresión se compone de dos partes: realiza el cálculo indicado por los
elementos de la expresión y devuelve el valor obtenido como resultado del cálculo.
Los operadores devuelven un valor, por lo que el uso de un operador es una expresión.
Por ejemplo, la siguiente sentencia es una expresión:
int contador=1;
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 40 de 189
contador++;
La expresión contaaor¹¹ en este caso particular se evalúa al valor 1, que era el valor de
la variable contaaor antes de que la operación ocurra, pero la variable contaaor
adquiere un valor de 2.
El tipo de datos del valor devuelto por una expresión depende de los elementos
utilizados en la expresión. La expresión contaaor¹¹ devuelve un entero porque ¹¹
devuelve un valor del mismo tipo que su operando y contaaor es un entero. Otras
expresiones devuelven valores booleanos, cadenas...
Una expresión de llamada a un método se evalúa al valor de retorno del método; así el
tipo de dato de la expresión de llamada a un método es el mismo que el tipo de dato del
valor de retorno de ese método.
Otra sentencia interesante sería:
in.read( ) != -1 // in es un flujo de entrada
Esta sentencia se compone de dos expresiones:
1. La primera expresión es una llamada al método in.reaa(). El método in.reaa() ha
sido declarado para devolver un entero, por lo que la expresión in.reaa() se evalúa a
un entero.
2. La segunda expresión contenida en la sentencia utiliza el operador ', que
comprueba si dos operandos son distintos. En la sentencia en cuestión, los
operandos son in.reaa() y -1. El operando in.reaa() es válido para el operador '
porque in.reaa() es una expresión que se evalúa a un entero, así que la expresión
in.reaa()'-1 compara dos enteros. El valor devuelto por esta expresión será
verdadero o falso dependiendo del resultado de la lectura del fichero in.
Como se puede observar, Java permite construir sentencias (expresiones compuestas) a
partir de varias expresiones más pequeñas con tal que los tipos de datos requeridos por
una parte de la expresión concuerden con los tipos de datos de la otra.
D. BLOQUES Y ÁMBITO
En Java el código fuente está dividido en partes separadas por llaves, denominas
bloques. Cada bloque existe independiente de lo que está fuera de él, agrupando en su
interior sentencias (expresiones) relacionadas.
Desde un bloque externo parece que todo lo que está dentro de llaves se ejecuta como
una sentencia. Pero, ¿qué es un bloque externo?. Esto tiene explicación si entendemos
que existe una ierarquia ae bloques, y que un bloque puede contener uno o más
subbloques anidados.
El concepto de ámbito está estrechamente relacionado con el concepto de bloque y es
muy importante cuando se trabaja con variables en Java. El ámbito se refiere a cómo las
secciones de un programa (bloques) afectan el tiempo de vida de las variables.
Toda variable tiene un ámbito, en el que es usada, que viene determinado por los
bloques. Una variable definida en un bloque interno no es visible por el bloque externo.
Las llaves de separación son importantes no sólo en un sentido lógico, ya que son la
forma de que el compilador diferencie dónde acaba una sección de código y dónde
comienza otra, sino que tienen una connotación estética que facilita la lectura de los
programas al ser humano.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 41 de 189
Así mismo, para identificar los diferentes bloques se utilizan sangrías. Las sangrías se
utilizan para el programador, no para el compilador. La sangría (también denominada
inaentacion) más adecuada para la estética de un programa Java son dos espacios:
{
// Bloque externo
int x = 1;
{
// Bloque interno invisible al exterior
int y = 2;
}
x = y; // Da error: Y fuera de ambito
}
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 42 de 189
II.2. TIPOS DE DATOS
A. TIPOS DE DATOS SIMPLES
Es uno de los conceptos fundamentales de cualquier lenguaje de programación. Estos
definen los métodos de almacenamiento disponibles para representar información, junto
con la manera en que dicha información ha de ser interpretada.
Para crear una variable (de un tipo simple) en memoria debe declararse indicando su
tipo de variable y su identificador que la identificará de forma única. La sintaxis de
declaración de variables es la siguiente:
TipoSimple Identificador1, Identificador2;
Esta sentencia indica al compilador que reserve memoria para dos variables del tipo
simple TipoSimple con nombres Iaentificaaor1 e Iaentificaaor2.
Los tipos de datos en Java pueden dividirse en dos categorías: simples y compuestos.
Los simples son tipos nucleares que no se derivan de otros tipos, como los enteros, de
coma flotante, booleanos y de carácter. Los tipos compuestos se basan en los tipos
simples, e incluyen las cadenas, las matrices y tanto las clases como las interfaces, en
general.
Cada tipo de datos simple soporta un conjunto de literales que le pueden ser asignados,
para darles valor. En este apartado se explican los tipos de datos simples (o primitivos)
que presenta Java, así como los literales que soporta (sintaxis de los valores que se les
puede asignar).
a.) Tipos de datos enteros
Se usan para representar números enteros con signo. Hay cuatro tipos: bvte. short. int v
long.
Tipo Tamaño
bvte 1Byte (8 bits)
short 2 Bytes (16 bits)
int 4 Bytes (32 bits)
long 8 Bytes (64 bits)
Tabla 5. Tipos ae aatos enteros
Literales enteros
Son básicos en la programación en Java y presentan tres formatos:
• Decimal: Los literales decimales aparecen como números ordinarios sin ninguna
notación especial.
• Hexadecimal: Los hexadecimales (base 16) aparecen con un 0x ó 0X inicial,
notación similar a la utilizada en C y C++.
• Octal: Los octales aparecen con un 0 inicial delante de los dígitos.
Por ejemplo, un literal entero para el número decimal 12 se representa en Java como 12
en decimal, como 0xC en hexadecimal, y como 014 en octal.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 43 de 189
Los literales enteros se almacenan por defecto en el tipo int, (4 bytes con signo), o si se
trabaja con números muy grandes, con el tipo long, (8 bytes con signo), añadiendo una
L ó l al final del número.
La declaración de variables enteras es muy sencilla. Un ejemplo de ello sería:
long numeroLargo = 0xC; // Por defecto vale 12
b.) Tipos de datos en coma flotante
Se usan para representar números con partes fraccionarias. Hay dos tipos de coma
flotante: float y aouble. El primero reserva almacenamiento para un número de
precisión simple de 4 bytes y el segundo lo hace para un numero de precisión doble de 8
bytes.
Tipo Tamaño
float 4 Byte (32 bits)
aouble 8 Bytes (64 bits)
Tabla 6. Tipos ae aatos numericos en coma flotante
Literales en coma flotante
Representan números decimales con partes fraccionarias. Pueden representarse con
notación estándar (563,84) o científica (5.6384e2).
De forma predeterminada son del tipo aouble (8 bytes). Existe la opción de usar un tipo
más corto (el tipo float de 4 bytes), especificándolo con una F ó f al final del número.
La declaración de variables de coma flotante es muy similar a la de las variables enteras.
Por ejemplo:
double miPi = 314.16e-2 ; // Aproximadamente
float temperatura = (float)36.6; // Paciente sin fiebre
Se realiza un moldeado a temperatura, porque todos los literales con decimales por
defecto se consideran aouble.
c.) Tipo de datos boolean
Se usa para almacenar variables que presenten dos estados, que serán representados por
los valores true y false. Representan valores bi-estado, provenientes del denominado
algebra ae bool.
Literales Booleanos
Java utiliza dos palabras clave para los estados: true (para verdadero) y false (para
falso). Este tipo de literales es nuevo respecto a C/C++, lenguajes en los que el valor de
falso se representaba por un 0 numérico, y verdadero cualquier número que no fuese el
0.
Para declarar un dato del tipo booleano se utiliza la palabra reservada boolean.
boolean reciboPagado = false; // ¡¿Aun no nos han pagado?!
d.) Tipo de datos carácter
Se usa para almacenar caracteres Unicoae simples. Debido a que el conjunto de
caracteres Unicoae se compone de valores de 16 bits, el tipo de datos char se almacena
en un entero sin signo de 16 bits.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 44 de 189
Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas.
Literales carácter
Representan un único carácter (de la tabla de caracteres Unicode 1.1) y aparecen dentro
de un par de comillas simples. De forma similar que en C/C++. Los caracteres
especiales (de control y no imprimibles) se representan con una barra invertida ('\')
seguida del código carácter.
Descripción Representación Valor Unicode
Caracter Unicode uaaaa
Numero octal aaa
Barra invertida u005C
Continuación
Retroceso b u0008
Retorno de carro r u000D
Alimentación de formularios f u000C
Tabulación horizontal t u0009
Línea nueva n u000A
Comillas simples u0027
Comillas dobles ` u0022
Números arábigos ASCII 0-9 u0030 a u0039
Alfabeto ASCII en mayúsculas A.-Z u0041 a u005A
Alfabeto ASCII en minúsculas a.-z u0061 a u007A
Tabla 7. Caracteres especiales Java
Las variables de tipo char se declaran de la siguiente forma:
char letraMayuscula = ’A’; // Observe la necesidad de las ’ ’
char letraV = ’\u0056’; // Letra ’V’
e.) Conversion de tipos de datos
En Java es posible transformar el tipo de una variable u objeto en otro diferente al
original con el que fue declarado. Este proceso se denomina "conversión", "moldeado"
o "tipado". La conversión se lleva a cabo colocando el tipo destino entre paréntesis, a la
izquierda del valor que queremos convertir de la forma siguiente:
char c = (char)System.in.read();
La función reaa devuelve un valor int, que se convierte en un char debido a la
conversión (char), y el valor resultante se almacena en la variable de tipo carácter c.
El tamaño de los tipos que queremos convertir es muy importante. No todos los tipos se
convertirán de forma segura. Por ejemplo, al convertir un long en un int, el compilador
corta los 32 bits superiores del long (de 64 bits), de forma que encajen en los 32 bits del
int, con lo que si contienen información útil, esta se perderá.
Por ello se establece la norma de que "en las conversiones el tipo destino siempre debe
ser igual o mayor que el tipo fuente":
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 45 de 189

Tipo Origen Tipo Destino
bvte aouble. float. long. int. char. short
short aouble. float. long. int
char aouble. float. long. int
int aouble. float. long
long aouble. float
float aouble
Tabla 8. Conversiones sin peraiaas ae informacion
B. VECTORES Y MATRICES
Una matriz es una construcción que proporciona almacenaje a una lista de elementos del
mismo tipo, ya sea simple o compuesto. Si la matriz tiene solo una dimensión, se la
denomina vector.
En Java los vectores se declaran utilizando corchetes ( [ v { ), tras la declaración del tipo
de datos que contendrá el vector. Por ejemplo, esta sería la declaración de un vector de
números enteros (int):
int vectorNumeros[ ]; // Vector de números
Se observa la ausencia de un número que indique cuántos elementos componen el
vector, debido a que Java no deja indicar el tamaño de un vector vacío cuando le
declara. La asignación de memoria al vector se realiza de forma explícita en algún
momento del programa.
Para ello o se utiliza el operador new:
int vectorNumeros = new int[ 5 ]; // Vector de 5 números
O se asigna una lista de elementos al vector:
int vectorIni = { 2, 5, 8}; // == int vectorIni[3]=new int[3];
Se puede observar que los corchetes son opcionales en este tipo de declaración de
vector, tanto después del tipo de variable como después del identificador.
Si se utiliza la forma de new se establecerá el valor 0 a cada uno de los elementos del
vector.
C. CADENAS
En Java se tratan como una clase especial llamada String. Las cadenas se gestionan
internamente por medio de una instancia de la clase String. Una instancia de la clase
String es un objeto que ha sido creado siguiendo la descripción de la clase.
Cadenas constantes
Representan múltiples caracteres y aparecen dentro de un par de comillas dobles. Se
implementan en Java con la clase String. Esta representación es muy diferente de la de
C/C++ de cadenas como una matriz de caracteres.
Cuando Java encuentra una constante de cadena, crea un caso de la clase String y define
su estado, con los caracteres que aparecen dentro de las comillas dobles.
Vemos un ejemplo de cadena declarada con la clase String de Java:
String capitalUSA = ”Washington D.C.”;
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 46 de 189
String nombreBonito = ”Amelia”;
Más tarde profundizaremos con detenimiento en las cadenas Java.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 47 de 189
II.3. OPERADORES
A. INTRODUCCIÓN
Los operadores son un tipo de tokens que indican una evaluación o computación para
ser realizada en objetos o datos, y en definitiva sobre identificadores o constantes.
Además de realizar la operación, un operador devuelve un valor, ya que son parte
fundamental de las expresiones.
El valor y tipo que devuelve depende del operador y del tipo de sus operandos. Por
ejemplo, los operadores aritméticos devuelven un número como resultado de su
operación.
Los operadores realizan alguna función sobre uno, dos o tres operandos.
Los operadores que requieren un operando son llamados operaaores unarios. Por
ejemplo, el operador "¹¹" es un operador unario que incrementa el valor de su
operando en una unidad.
Los operadores unarios en Java pueden utilizar tanto la notación prefija como la posfija.
La notación prefija indica que el operador aparece antes que su operando.
++contador // Notación prefija, se evalúa a: contador+1
La notación posfija indica que el operador aparece después de su operando:
contador++ // Notación posfija, se evalúa a: contador
Los operadores que requieren dos operandos se llaman operaaores binarios. Por
ejemplo el operador "" es un operador binario que asigna el valor del operando del
lado derecho al operando del lado izquierdo.
Todas los operadores binarios en Java utilizan notación infija, lo cual indica que el
operador aparece entre sus operandos.
operando1 operador operando2
Por último, los operadores ternarios son aquellos que requieren tres operandos. El
lenguaje Java tiene el operador ternario, "?":, que es una sentencia similar a la if-else.
Este operador ternario usa notación infija; y cada parte del operador aparece entre
operandos:
expresión ? operación1 : operación2
Los operadores de Java se pueden dividir en las siguientes cuatro categorías:
Œ Aritméticos.
Œ De comparación y condicionales.
Œ A nivel de bits y lógicos.
Œ De asignación.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 48 de 189
B. OPERADORES ARITMÉTICOS
El lenguaje Java soporta varios operadores aritméticos para los números enteros y en
coma flotante. Se incluye ¹ (suma), - (resta), ' (multiplicación), / (división), y º
(módulo, es decir, resto de una división entera). Por ejemplo:
sumaEste + aEste; //Suma los dos enteros
divideEste % entreEste; //Calcula el resto de dividir 2 enteros
Operador Uso Descripción
¹ op1 ¹ op2 Suma op1 y op2
- op1 - op2 Resta op2 de op1
' op1 ' op2 Multiplica op1 por op2
/ op1 / op2 Divide op1 por op2
º op1 º op2 Calcula el resto de dividir op1 entre op2
Tabla 9. Operaaores aritmeticos binarios ae Java
El tipo de los datos devueltos por una operación aritmética depende del tipo de sus
operandos; si se suman dos enteros, se obtiene un entero como tipo devuelto con el
valor de la suma de los dos enteros.
Estos operadores se deben utilizar con operandos del mismo tipo, o si no realizar una
conversión de tipos de uno de los dos operandos al tipo del otro.
El lenguaje Java sobrecarga la definición del operador ¹ para incluir la concatenación
de cadenas. El siguiente ejemplo utiliza ¹ para concatenar la cadena "Contaaos ", con el
valor de la variable contaaor y la cadena " caracteres.":
System.out.print("Contados" + contador + "caracteres.");
Esta operación automáticamente convierte el valor de contaaor a una cadena de
caracteres.
Los operadores + y - tienen versiones unarias que realizan las siguientes operaciones:
Operador Uso Descripción
+ +op Convierte op a entero si es un byte, short o char
- -op Niega aritméticamente op
Tabla 10. Jersiones unarias ae los operaaores "¹" v "-"
El operador - realiza una negación del número en complemento A2, es decir, cambiando
de valor todos sus bits y sumando 1 al resultado final:
42 -> 00101010
-42 -> 11010110
Existen dos operadores aritméticos que funcionan como atajo de la combinación de
otros: ++ que incrementa su operando en 1, y -- que decrementa su operando en 1.
Ambos operadores tienen una versión prefija, y otra posfija. La utilización la correcta es
crítica en situaciones donde el valor de la sentencia es utilizado en mitad de un cálculo
más complejo, por ejemplo para control de flujos:
Operador Uso Descripción
¹¹ op¹¹ Incrementa op en 1; se evalúa al valor anterior al incremento
¹¹ ¹¹op Incrementa op en 1; se evalúa al valor posterior al incremento
-- op-- Decrementa op en 1; se evalúa al valor anterior al incremento
-- --op Decrementa op en 1; se evalúa al valor posterior al incremento
Tabla 11. Operaciones con "¹¹" v "--"
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 49 de 189
C. OPERADORES DE COMPARACIÓN Y CONDICIONALES
Un operador de comparación compara dos valores y determina la relación existente
entre ambos. Por ejemplo, el operador ' devuelve verdadero (true) si los dos
operandos son distintos. La siguiente tabla resume los operadores de comparación de
Java:
Operador Uso Devuelve verdadero si
> op1 > op2 op1 es mayor que op2
>= op1 >= op2 op1 es mayor o igual que op2
< op1 < op2 op1 es menor que op2
<= op1 <= op2 op1 es menor o igual que op2
== op1 == op2 op1 y op2 son iguales
!= op1 != op2 op1 y op2 son distintos
Tabla 12. Operaaores ae comparacion
Los operadores de comparación suelen ser usados con los operadores condicionales para
construir expresiones complejas que sirvan para la toma de decisiones. Un operador de
este tipo es &&, el cual realiza la operación booleana ana. Por ejemplo, se pueden
utilizar dos operaciones diferentes de comparación con && para determinar si ambas
relaciones son ciertas. La siguiente línea de código utiliza esta técnica para determinar si
la variable inaex de una matriz se encuentra entre dos límites (mayor que cero y menor
que la constante NUMEROENTRADAS):
( 0 < index ) && ( index < NUMERO_ENTRADAS )
Se debe tener en cuenta que en algunos casos, el segundo operando de un operador
condicional puede no ser evaluado. En caso de que el primer operando del operador &&
valga falso, Java no evaluará el operando de la derecha:
(contador < NUMERO_ENTRADAS) && ( in.read() != -1 )
Si contaaor es menor que NUMEROENTRADAS, el valor de retorno de && puede ser
determinado sin evaluar el operando de la parte derecha. En este caso in.reaa no será
llamado y un carácter de la entrada estándar no será leído.
Si el programador quiere que se evalúe la parte derecha, deberá utilizar el operador & en
lugar de &&.
De la misma manera se relacionan los operadores || y [ para la exclusión lógica (OR).
Java soporta cinco operadores condicionales , mostrados en la siguiente tabla:
Operador Uso Devuelve verdadero si...
&& op1 && op2 op1 y op2 son ambos verdaderos, condicionalmente evalúa op2
& op1 & op2 op1 y op2 son ambos verdaderos, siempre evalúa op1 y op2
[[ op1 [[ op2 op1 o op2 son verdaderos, condicionalmente evalúa op2
[ op1 [ op2 op1 o op2 son verdaderos, siempre evalúa op1 y op2
' ' op op es falso
Tabla 13. Operaaores conaicionales
Además Java soporta un operador ternario, el ?., que se comporta como una versión
reducida de la sentencia if-else:
expresion ? operacion1 : operacion2
El operador ?: evalúa la expresion y devuelve operacion1 si es cierta, o devuelve
operacion2 si expresion es falsa.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 50 de 189
D. OPERADORES DE BIT
Un operador de bit permite realizar operaciones de bit sobre los datos. Existen dos tipos:
los que desplazan (mueven) bits, y operadores lógicos de bit.
a.) Operadores de desplazamiento de bits
Operador Uso Operación
~~ op1 ~~ op2 Desplaza los bits de op1 a la derecha op2 veces
·· op1 ·· op2 Desplaza los bits de op1 a la izquierda op2 veces
~~~ op1 ~~~ op2 Desplaza los bits de op1 a la derecha op2 veces (sin signo)
Tabla 14. Operaaores ae aesplazamiento ae bits
Los tres operadores de desplazamiento simplemente desplazan los bits del operando de
la parte izquierda el número de veces indicado por el operando de la parte derecha. El
desplazamiento ocurre en la dirección indicada por el operador. Por ejemplo, la
siguiente sentencia, desplaza los bits del entero 13 a la derecha una posición:
13 >> 1;
La representación en binario del número 13 es 1101. El resultado de la operación de
desplazamiento es 1101 desplazado una posición a la derecha, 110 o 6 en decimal. Se
debe tener en cuenta que el bit más a la derecha se pierde en este caso.
Un desplazamiento a la derecha una posición es equivalente a dividir el operando del
lado izquierdo por 2, mientras que un desplazamiento a la izquierda de una posición
equivale a multiplicar por 2, pero un desplazamiento es más eficiente,
computacionalmente hablando, que una división o multiplicación.
El desplazamiento sin signo ~~~ funciona de la siguiente manera:
Œ Si se desplaza con signo el número -1 (1111), seguirá valiendo -1, dado que la
extensión de signo sigue introduciendo unos en los bits más significativos.
ΠCon el desplazamiento sin signo se consigue introducir ceros por la izquierda,
obteniendo el número 7 (0111).
Este tipo de desplazamientos es especialmente útil en la utilización de máscaras
gráficas.
b.) Operadores de lógica de bits
La lógica de bits (lógica de Bool) se utiliza para modelizar condiciones biestado y
trabajar con ellas (cierto/falso, true/false, 1/0).
En Java hay cuatro operadores de lógica de bits:
Operador Uso Operación
& op1 & op2 AND
[ op1 [ op2 OR
´ op1 ´ op2 OR Exclusivo
op2 Complemento
Tabla 15. Operaaores ae logica ae bits
El operador & realiza la operación AND de bit. Aplica la funcion AND sobre cada par
de bits de igual peso de cada operando. La funcion AND es evaluada a cierto si ambos
operandos son ciertos.
Por ejemplo vamos a aplicar la operación AND a los valores 12 y 13:
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 51 de 189
12 & 13
El resultado de esta operación es 12. ¿Por qué?. La representación en binario de 12 es
1100, y de 13 es 1101. La funcion AND pone el bit de resultado a uno si los dos bits de
los operandos son 1, sino, el bit de resultado es 0:
1101
& 1100
------
1100
El operador [ realiza la operación OR de bit. Aplica la funcion OR sobre cada par de bits
de igual peso de cada operando. La funcion OR es evaluada a cierto si alguno de los
operandos es cierto.
El operador ^ realiza la operación OR exclusivo de bit (XOR). Aplica la funcion XOR
sobre cada par de bits de igual peso de cada operando. La funcion XOR es evaluada a
cierto si los operandos tienen el mismo valor.
Para finalizar, el operador de complemento invierte el valor de cada bit del operando.
Convierte el falso en cierto, y el cierto en falso:
Entre otras cosas, la manipulación bit es útil para gestionar indicadores booleanos
(banderas). Supongamos, por ejemplo, que se tiene varios indicadores booleanos en
nuestro programa, los cuales muestran el estado de varios componentes del programa:
esJisible, esArrastrable.... En lugar de definir una variable booleana para cada
indicador, se puede definir una única variable para todos ellos. Cada bit de dicha
variable representará el estado vigente de uno de los indicadores. Se deberán utilizar
entonces manipulaciones de bit para establecer y leer cada indicador.
Primero, se deben preparar las constantes de cada indicador. Esos indicadores deben ser
diferentes unos de otros (en sus bits) para asegurar que el bit de activación no se solape
con otro indicador. Después se debe definir la variable de banderas, cuyos bits deben de
poder ser configurados según el estado vigente en cada indicador.
El siguiente ejemplo inicia la variable de banderas flags a 0, lo que significa que todos
los indicadores están desactivados (ninguno de los bits es 1):
final int VISIBLE = 1;
final int ARRASTRABLE = 2;
final int SELECCIONABLE = 4;
final int MODIFICABLE = 8;
int flags = 0;
Para activar el indicador JISIBLE, se deberá usar la sentencia:
flags = flags | VISIBLE;
Para comprobar la visibilidad se deberá usar la sentencia:
if ( (flags & VISIBLE) == 1 )
//Lo que haya que hacer
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 52 de 189
E. OPERADORES DE ASIGNACIÓN
El operador de asignación básico es el , que se utiliza para asignar un valor a otro. Por
ejemplo:
int contador = 0;
Inicia la variable contaaor con un valor 0.
Java además proporciona varios operadores de asignación que permiten realizar un atajo
en la escritura de código. Permiten realizar operaciones aritméticas, lógicas, de bit y de
asignación con un único operador.
Supongamos que necesitamos sumar un número a una variable y almacenar el resultado
en la misma variable, como a continuación:
i = i + 2;
Se puede abreviar esta sentencia con el operador de atajo ¹, de la siguiente manera.
i += 2;
La siguiente tabla muestra los operadores de atajo de asignación y sus equivalentes
largos:
Operador Uso Equivalente a
¹ op1 ¹ op2 op1 = op1 + op2
- op1 - op2 op1 = op1 - op2
' op1 ' op2 op1 = op1 * op2
/ op1 / op2 op1 = op1 / op2
º op1 º op2 op1 = op1 % op2
& op1 & op2 op1 = op1 & op2
Tabla 16. Operaaores ae ataio ae asignacion
F. PRECEDENCIA DE OPERADORES
Cuando en una sentencia aparecen varios operadores el compilador deberá de elegir en
qué orden aplica los operadores. A esto se le llama preceaencia.
Los operadores con mayor precedencia son evaluados antes que los operadores con una
precedencia relativa menor.
Cuando en una sentencia aparecen operadores con la misma precedencia:
Œ Los operadores de asignación son evaluados de derecha a izquierda.
Œ Los operadores binarios, (menos los de asignación) son evaluados de izquierda a
derecha.
Se puede indicar explícitamente al compilador de Java cómo se desea que se evalúe la
expresión con paréntesis balanceados ( ). Para hacer que el código sea más fácil de leer
y mantener, es preferible ser explícito e indicar con paréntesis que operadores deben ser
evaluados primero.
La siguiente tabla muestra la precedencia asignada a los operadores de Java. Los
operadores de la tabla están listados en orden de precedencia: cuanto más arriba
aparezca un operador, mayor es su precedencia. Los operadores en la misma línea
tienen la misma precedencia:
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 53 de 189
Tipo de operadores Operadores de este tipo
Operadores posfijos [ ] . (parametros) expr++ expr--
Operadores unarios ++expr --expr +expr -expr ~ !
Creación o conversión new (tipo) expr
Multiplicación * / %
Suma + -
Desplazamiento <<
Comparación < <= = instanceof
Igualdad == !=
AND a nivel de bit &
OR a nivel de bit ^
XOR a nivel de bit |
AND lógico &&
OR lógico ||
Condicional ? :
Asignación = += -= *= /= %= &= ^= |= <<= = =
Tabla 17. Preaeaencia ae operaaores
Por ejemplo, la siguiente expresión produce un resultado diferente dependiendo de si se
realiza la suma o división en primer lugar:
x + y / 100
Si no se indica explícitamente al compilador el orden en que se quiere que se realicen
las operaciones, entonces el compilador decide basándose en la precedencia asignada a
los operadores. Como el operador de división tiene mayor precedencia que el operador
de suma el compilador evaluará v/100 primero.
Así:
x + y / 100
Es equivalente a:
x + (y / 100)
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 54 de 189
II.4. ESTRUCTURAS DE CONTROL
A. INTRODUCCIÓN
Durante un programa existen acciones que se han de repetir un número determinado de
veces. Por ejemplo, leer 3 caracteres de un flujo de entrada in se codificaría:
in.read();
in.read();
in.read();
Este código además de poco elegante sería inviable para una repetición de 3000
lecturas. Por eso aparecen las estructuras de control, que facilitan que determinadas
acciones se realicen varias veces, mientras que una condición se cumpla, y en definitiva,
tomar decisiones de qué hacer en función de las condiciones que se den en el programa
en un momento dado de su ejecución.
Así, nuestro ejemplo se podría indicar como:
int i=0;
for ( i=0 ; i <= 3 ; i++ )
in.read();
Donde bastaría cambiar el 3 por cualquier otro número para que la lectura se repitiese
ese número de veces.
El lenguaje Java soporta las estructuras de control:
Sentencia Clave
Toma de decisión if-else, switch-case
Bucle for, while, do-while
Misceláneo break, continue, label:, return, goto
Tabla 18. Estructuras ae control
Aunque goto es una palabra reservada, actualmente el lenguaje Java no soporta la
sentencia goto. Se puede utilizar las sentencias de bifurcación en su lugar.
B. LAS SENTENCIAS CONDICIONALES: IF Y SWITCH
a.) La sentencia if - else
La sentencia if-else de Java dota a los programas de la habilidad de ejecutar distintos
conjuntos de sentencias según algún criterio.
La sintaxis de la sentencia if-else es:
if ( condición )
Bloque de código a ejecutar si la condición es cierta
else
Bloque de código a ejecutar si la condición es falsa
La parte del else es opcional, y un bloque de código puede ser simplemente la sentencia
vacía , para representar que en ese caso no se ha de ejecutar nada.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 55 de 189
Supongamos que un programa debe realizar diferentes acciones dependiendo de si el
usuario oprime el botón aceptar o el botón cancelar en una ventana de dialogo. Nuestro
programa puede realizar esto usando la sentencia if - else:
// La respuesta es Aceptar o Cancelar
if (respuesta == Aceptar) {
// código para realizar la acción Aceptar
System.out.println( "Su peticion esta siendo atendida" );
}
else {
// código para realizar la acción Cancelar
System.out.println( "Cancelando accion" );
}
Se pueden anidar expresiones if-else, para poder implementar aquellos casos con
múltiples acciones. Esto es lo que se suele denominar como sentencias else if.
Por ejemplo, supongamos que se desea escribir un programa que clasifique según el
contenido de una variable valor, asigne una letra a una variable clasificacion: A para un
valor del 100-91, B de 90-81, C para 80-71 y F si no es ninguno de los anteriores:
int valor;
char clasificacion;
if (valor > 90)
{clasificacion=’A’;}
else
if (valor > 80)
{clasificacion=’B’;}
else
if (valor > 70)
{clasificacion=’C’;}
else
{clasificacion=’F’;}
Se pueden escribir los if en las mismas líneas que los else, pero desde este tutorial se
insta a utilizar la forma indentada (como se ha podido ver en el ejemplo), pues es más
clara para el lector.
Este sistema de programación (else if) no es demasiado recomendable, y por ello el
lenguaje Java incluye la sentencia switch. que veremos a continuación, para dirigir el
flujo de control de variables con múltiples valores.
b.) La sentencia switch
Mediante la sentencia switch se puede seleccionar entre varias sentencias según el valor
de cierta expresión.
La forma general de switch es la siguiente:
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 56 de 189
switch ( expresionMultivalor ) {
case valor1 : conjuntoDeSentencias; break;
case valor2 : conjuntoDeSentencias; break;
case valor3: conjuntoDeSentencias; break;
default: conjuntoDeSentencias; break;
}
La sentencia switch evalúa la expresionMultivalor y ejecuta el coniuntoDeSentencias
que aparece junto a la cláusula case cuyo valor corresponda con el de la
expresionMultivalor.
Cada sentencia case debe ser única y el valor que evalúa debe ser del mismo tipo que el
devuelto por la expresionMultivalor de la sentencia switch.
Las sentencias break que aparecen tras cada coniuntoDeSentencias provocan que el
control salga del switch y continúe con la siguiente instrucción al switch. Las sentencias
break son necesarias porque sin ellas se ejecutarían secuencialmente las sentencias case
siguientes. Existen ciertas situaciones en las que se desea ejecutar secuencialmente
algunas o todas las sentencias case, para lo que habrá que eliminar algunos break.
Finalmente, se puede usar la sentencia aefault para manejar los valores que no son
explícitamente contemplados por alguna de las sentencias case. Su uso es altamente
recomendado.
Por ejemplo, supongamos un programa con una variable entera meses cuyo valor indica
el mes actual, y se desea imprimir el nombre del mes en que estemos. Se puede utilizar
la sentencia switch para realizar esta operación:
int meses;
switch ( meses ){
case 1: System.out.println( "Enero" ); break;
case 2: System.out.println( "Febrero" ); break;
case 3: System.out.println( "Marzo" ); break;
//Demas meses
// . . .
case 12: System.out.println( "Diciembre" ); break;
default: System.out.println( "Mes no valido" ); break;
}
Por supuesto, se puede implementar esta estructura como una sentencia if else if:
int meses;
if ( meses == 1 ) {
System.out.println( "Enero" );
}
else
if ( meses == 2 ) {
System.out.println( "Febrero" );
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 57 de 189
}
// Y así para los demás meses
El decidir si usar la sentencia if o switch depende del criterio de cada caso. Se puede
decidir cuál usar basándonos en la legibilidad, aunque se recomienda utilizar switch
para sentencias con más de tres o cuatro posibilidades.
C. SENTENCIAS DE ITERACIÓN O BUCLES: FOR, DO, WHILE
a.) Bucle while
El bucle while es el bucle básico de iteración. Sirve para realizar una acción
sucesivamente mientras se cumpla una determinada condición.
La forma general del bucle while es la siguiente:
while ( expresiónBooleana ) {
sentencias;
};
Las sentencias se ejecutan mientras la expresionBooleana tenga un valor de veraaaero.
Se utiliza, por ejemplo para estar en un bucle del que no hay que salir hasta que no se
cumpla una determinada condición. Por ejemplo, multiplicar un número por 2 hasta que
sea mayor que 100:
int i = 1;
while ( i <= 100 ) {
i = i * 2;
}
Con él se podrían eliminar los bucles ao-while y for por ser extensiones de éste, pero
que se incluyen en el lenguaje para facilitar la programación.
b.) Bucle do-while
El bucle ao-while es similar al bucle while, pero en el bucle while la expresión se evalúa
al principio del bucle y en el bucle ao-while la evaluación se realiza al final.
La forma general del bucle ao-while es la siguiente:
do {
sentencias;
} while ( expresiónBooleana );
La sentencia ao-while es el constructor de bucles menos utilizado en la programación,
pero tiene sus usos, cuando el bucle deba ser ejecutado por lo menos una vez.
Por ejemplo, cuando se lee información de un archivo, se sabe que siempre se debe leer
por lo menos un carácter:
int c;
do {
c = System.in.read( );
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 58 de 189
// Sentencias para tratar el carácter c
} while ( c != -1 ); // No se puede leer más (Fin fichero)
c.) Bucle for
Mediante la sentencia for se resume un bucle ao-while con una iniciación previa. Es
muy común que en los bucles while y ao-while se inicien las variables de control de
número de pasadas por el bucle, inmediatamente antes de comenzar los bucles. Por eso
el bucle for está tan extendido.
La forma general de la sentencia for es la siguiente:
for ( iniciación ; terminación ; incremento )
sentencias;
La iniciación es una sentencia que se ejecuta una vez antes de entrar en el bucle.
La terminación es una expresión que determina cuándo se debe terminar el bucle. Esta
expresión se evalúa al final de cada iteración del bucle. Cuando la expresión se evalúa a
falso, el bucle termina.
El incremento es una expresión que es invocada en cada iteración del bucle. En realidad
puede ser una acción cualquiera, aunque se suele utilizar para incrementar una variable
contador:
for ( i = 0 ; i < 10 ; i++ )
Algunos (o todos) estos componentes pueden omitirse, pero los puntos y coma siempre
deben aparecer (aunque sea sin nada entre sí).
Se debe utilizar el bucle for cuando se conozcan las restricciones del bucle (su
instrucción de iniciación, criterio de terminación e instrucción de incremento).
Por ejemplo, los bucles for son utilizados comúnmente para iterar sobre los elementos
de una matriz, o los caracteres de una cadena:
// cad es una cadena (String)
for ( int i = 0; i < cad.length() ; i++){
// hacer algo con el elemento i-ésimo de cad
}
D. SENTENCIAS DE SALTO: BREAK, CONTINUE Y RETURN
a.) Sentencia break
La sentencia break provoca que el flujo de control salte a la sentencia inmediatamente
posterior al bloque en curso. Ya se ha visto anteriormente la sentencia break dentro de
la sentencia switch.
El uso de la sentencia break con sentencias etiquetadas es una alternativa al uso de la
sentencia goto, que no es soportada por el lenguaje Java.
Se puede etiquetar una sentencia poniendo una identificador Java válido seguido por
dos puntos antes de la sentencia:
nombreSentencia: sentenciaEtiquetada
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 59 de 189
La sentencia break se utiliza para salir de una sentencia etiquetada, llevando el flujo del
programa al final de la sentencia de programa que indique:
break nombreSentencia2;
Un ejemplo de esto sería el programa:
void gotoBreak() {
System.out.println("Ejemplo de break como ’goto’ ");
a: for( int i=1; i<10; i++ ){
System.out.print(" i="+i);
for( int j=1; j<10; j++ ){
if ( j==5 )
break a; //Sale de los dos bucles!!!
System.out.print(" j="+j);
}
System.out.print("No llega aquí");
}
}
Al interpretar break a, no solo se rompe la ejecución del bucle interior (el de i), sino que
se salta al final del bucle i, obteniéndose:
i=1 j=1 j=2 j=3
Nota: Se desaconseja esta forma de programación, basada en goto, y con saltos de flujo
no controlados.
b.) Sentencia continue
Del mismo modo que en un bucle se puede desear romper la iteración, también se puede
desear continuar con el bucle, pero dejando pasar una determinada iteración.
Se puede usar la sentencia continue dentro de los bucles para saltar a otra sentencia,
aunque no puede ser llamada fuera de un bucle.
Tras la invocación a una sentencia continue se transfiere el control a la condición de
terminación del bucle, que vuelve a ser evaluada en ese momento, y el bucle continúa o
no dependiendo del resultado de la evaluación. En los bucles for además en ese
momento se ejecuta la cláusula de incremento (antes de la evaluación). Por ejemplo el
siguiente fragmento de código imprime los números del 0 al 9 no divisibles por 3:
for ( int i = 0 ; i < 10 ; i++ ) {
if ( ( i % 3 ) == 0 )
continue;
System.out.print( " " + i );
}
Del mismo modo que break, en las sentencias continue se puede indicar una etiqueta de
bloque al que hace referencia. Con ello podemos referirnos a un bloque superior, si
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 60 de 189
estamos en bucles anidados. Si dicha etiqueta no es indicada, se presupone que nos
referimos al bucle en el que la sentencia continue aparece.
Por ejemplo, el siguiente fragmento de código:
void gotoContinue( ) {
f: for ( int i=1; i <5; i++ ) {
for ( int j=1; j<5; j++ ) {
if ( j>i ) {
System.out.println(" ");
continue f;
}
System.out.print( " " + (i*j) );
}
}
}
En este código la sentencia continue termina el bucle de i y continua el flujo en la
siguiente iteración de i. Ese método imprimiría:
1
2 4
3 6 9
4 8 12 16
Nota: Se desaconseja esta forma de programación, basada en goto, y con saltos de flujo
no controlados.
c.) Sentencia return
La última de las sentencias de salto es la sentencia return, que puede usar para salir del
método en curso y retornar a la sentencia dentro de la cual se realizó la llamada.
Para devolver un valor, simplemente se debe poner el valor (o una expresión que calcule
el valor) a continuación de la palabra return. El valor devuelto por return debe coincidir
con el tipo declarado como valor de retorno del método.
Cuando un método se declara como voia se debe usar la forma de return sin indicarle
ningún valor. Esto se hace para no ejecutar todo el código del programa:
int contador;
boolean condicion;
int devuelveContadorIncrementado(){
return ++contador;
}
void metodoReturn(){
//Sentencias
if ( condicion == true )
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 61 de 189
return;
//Más sentencias a ejecutar si condición no vale true
}
E. EXCEPCIONES
Las excepciones son otra forma más avanzada de controlar el flujo de un programa. Con
ellas se podrán realizar acciones especiales si se dan determinadas condiciones, justo en
el momento en que esas condiciones se den.
Estudiaremos más este sistema de control en el capítulo "II.8. Gestion ae excepciones v
errores" de este tutorial.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 62 de 189
II.5. CLASES Y OBJETOS
A. INTRODUCCIÓN
Durante los capítulos anteriores se han dado unas nociones básicas de la sintaxis de
Java. A partir de ahora es cuando entramos la verdadera potencia de Java como lenguaje
orientado a objetos: las clases y los objetos.
Aquellas personas que nunca hayan programado en un lenguaje orientado a objeto, o
que no conozcan las nociones básicas de paradigma conviene que lean el capítulo "I.1
Introauccion a la programacion orientaaa a obietos" de este tutorial, ya que a partir de
ahora los conceptos que en él se exponen se darán por entendidos.
Durante todo este capítulo se va a trabajar en la construcción de una clase MiPunto, que
modeliza un punto en un espacio plano:
class MiPunto{
int x, y;
int metodoSuma( int paramX, int paramY ) {
return ( paramX + paramY );
}
double distancia(int x, int y) {
int dx= this.x – pX;
int dy = this.y – pY;
return Math.sqrt(dx*dx + dy*dy);
}
void metodoVacio( ) { }
void inicia( int paramX, int paramY ) {
x = paramX;
y = paramY;
}
void inicia2( int x, int y ) {
x = x; // Ojo, no modificamos la variable de instancia!!!
this.y = y; // Modificamos la variable de instancia!!!
}
MiPunto( int paramX, int paramY ) {
this.x = paramX; // Este this se puede omitir
y = paramY; // No hace falta this
}
MiPunto() {
inicia(-1,-1); //Por defecto ; this(-1,-1) hace lo mismo
}
}
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 63 de 189
B. DEFINICIÓN DE UNA CLASE
a.) Introducción
El elemento básico de la programación orientada a objetos en Java es la clase. Una clase
define la forma y comportamiento de un objeto.
Para crear una clase sólo se necesita un archivo fuente que contenga la palabra clave
reservada class seguida de un identificador legal y un bloque delimitado por dos llaves
para el cuerpo de la clase.
class MiPunto {
}
Un archivo de Java debe tener el mismo nombre que la clase que contiene, y se les suele
asignar la extensión ".iava". Por ejemplo la clase MiPunto se guardaría en un fichero
que se llamase MiPunto.iava. Hay que tener presente que en Java se diferencia entre
mayúsculas y minúsculas; el nombre de la clase y el de archivo fuente han de ser
exactamente iguales.
Aunque la clase MiPunto es sintácticamente correcta, es lo que se viene a llamar una
clase vacia, es decir, una clase que no hace nada. Las clases típicas de Java incluirán
variables y métodos de instancia. Los programas en Java completos constarán por lo
general de varias clases de Java en distintos archivos fuente.
Una clase es una plantilla para un objeto. Por lo tanto define la estructura de un objeto y
su interfaz funcional, en forma de métodos. Cuando se ejecuta un programa en Java, el
sistema utiliza definiciones de clase para crear instancias de las clases, que son los
objetos reales. Los términos instancia y objeto se utilizan de manera indistinta. La forma
general de una definición de clase es:
class Nombre_De_Clase {
tipo_de_variable nombre_de_atributo1;
tipo_de_variable nombre_de_atributo2;
// . . .
tipo_devuelto nombre_de_método1( lista_de_parámetros ) {
cuerpo_del_método1;
}
tipo_devuelto nombre_de_método2( lista_de_parámetros ) {
cuerpo_del_método2;
}
// . . .
}
Los tipos tipoaevariable y tipoaevuelto, han de ser tipos simples Java o nombres de
otras clases ya definidas. Tanto NombreDeClase, como los nombreaeatributo y
nombreaemetoao, han de ser identificadores Java válidos.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 64 de 189
b.) Los atributos
Los datos se encapsulan dentro de una clase declarando variables dentro de las llaves de
apertura y cierre de la declaración de la clase, variables que se conocen como atributos.
Se declaran igual que las variables locales de un método en concreto.
Por ejemplo, este es un programa que declara una clase MiPunto, con dos atributos
enteros llamados x e y.
class MiPunto {
int x, y;
}
Los atributos se pueden declarar con dos clases de tipos: un tipo simple Java (ya
descritos), o el nombre de una clase (será una referencia a obieto, véase el punto C.a de
este mismo apartado).
Cuando se realiza una instancia de una clase (creación de un objeto) se reservará en la
memoria un espacio para un conjunto de datos como el que definen los atributos de una
clase. A este conjunto de variables se le denomina variables ae instancia.
c.) Los métodos
Los métodos son subrutinas que definen la interfaz de una clase, sus capacidades y
comportamiento.
Un método ha de tener por nombre cualquier identificador legal distinto de los ya
utilizados por los nombres de la clase en que está definido. Los métodos se declaran al
mismo nivel que las variables de instancia dentro de una definición de clase.
En la declaración de los métodos se define el tipo de valor que devuelven y a una lista
formal de parámetros de entrada, de sintaxis tipo iaentificaaor separadas por comas. La
forma general de una declaración de método es:
tipo_devuelto nombre_de_método( lista-formal-de-parámetros ) {
cuerpo_del_método;
}
Por ejemplo el siguiente método devuelve la suma de dos enteros:
int metodoSuma( int paramX, int paramY ) {
return ( paramX + paramY );
};
En el caso de que no se desee devolver ningún valor se deberá indicar como tipo la
palabra reservada voia. Así mismo, si no se desean parámetros, la declaración del
método debería incluir un par de paréntesis vacíos (sin voia):
void metodoVacio( ) { };
Los métodos son llamados indicando una instancia individual de la clase, que tendrá su
propio conjunto único de variables de instancia, por lo que los métodos se pueden
referir directamente a ellas.
El método inicia() para establecer valores a las dos variables de instancia sería el
siguiente:
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 65 de 189
void inicia( int paramX, int paramY ) {
x = paramX;
y = paramY;
}
C. LA INSTANCIACIÓN DE LAS CLASES: LOS OBJETOS
a.) Referencias a Objeto e Instancias
Los tipos simples de Java describían el tamaño y los valores de las variables. Cada vez
que se crea una clase se añade otro tipo de dato que se puede utilizar igual que uno de
los tipos simples. Por ello al declarar una nueva variable, se puede utilizar un nombre de
clase como tipo. A estas variables se las conoce como referencias a obieto.
Todas las referencias a objeto son compatibles también con las instancias de subclases
de su tipo. Del mismo modo que es correcto asignar un bvte a una variable declarada
como int, se puede declarar que una variable es del tipo MiClase y guardar una
referencia a una instancia de este tipo de clase:
MiPunto p;
Esta es una declaración de una variable p que es una referencia a un objeto de la clase
MiPunto, de momento con un valor por defecto de null. La referencia null es una
referencia a un objeto de la clase Obiect, y se podrá convertir a una referencia a
cualquier otro objeto porque todos los objetos son hiios de la clase Obiect.
b.) Constructores
Las clases pueden implementar un método especial llamado constructor. Un constructor
es un método que inicia un objeto inmediatamente después de su creación. De esta
forma nos evitamos el tener que iniciar las variables explícitamente para su iniciación.
El constructor tiene exactamente el mismo nombre de la clase que lo implementa; no
puede haber ningún otro método que comparta su nombre con el de su clase. Una vez
definido, se llamará automáticamente al constructor al crear un objeto de esa clase (al
utilizar el operador new).
El constructor no devuelve ningún tipo, ni siquiera voia. Su misión es iniciar todo
estado interno de un objeto (sus atributos), haciendo que el objeto sea utilizable
inmediatamente; reservando memoria para sus atributos, iniciando sus valores...
Por ejemplo:
MiPunto( ) {
inicia( -1, -1 );
}
Este constructor denominado constructor por aefecto, por no tener parámetros,
establece el valor -1 a las variables de instancia x e v de los objetos que construya.
El compilador, por defecto ,llamará al constructor de la superclase Obiect() si no se
especifican parámetros en el constructor.
Este otro constructor, sin embargo, recibe dos parámetros:
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 66 de 189
MiPunto( int paraX, int paraY ) {
inicia( paramX, paramY );
}
La lista de parámetros especificada después del nombre de una clase en una sentencia
new se utiliza para pasar parámetros al constructor.
Se llama al método constructor justo después de crear la instancia y antes de que new
devuelva el control al punto de la llamada.
Así, cuando ejecutamos el siguiente programa:
MiPunto p1 = new MiPunto(10, 20);
System.out.println( “p1.- x = “ + p1.x + “ y = “ + p1.y );
Se muestra en la pantalla:
p1.- x = 10 y = 20
Para crear un programa Java que contenga ese código, se debe de crear una clase que
contenga un método main(). El intérprete iava se ejecutará el método main de la clase
que se le indique como parámetro.
Para más información sobre cómo crear y ejecutar un programa, así como los tipos de
programas que se pueden crear en Java, véase el capítulo "II.12. Creacion ae programas
Java" de este tutorial.
c.) El operador new
El operador new crea una instancia de una clase (obietos) y devuelve una referencia a
ese objeto. Por ejemplo:
MiPunto p2 = new MiPunto(2,3);
Este es un ejemplo de la creación de una instancia de MiPunto, que es controlador por la
referencia a objeto p2.
Hay una distinción crítica entre la forma de manipular los tipos simples y las clases en
Java: Las referencias a objetos realmente no contienen a los objetos a los que
referencian. De esta forma se pueden crear múltiples referencias al mismo objeto, como
por ejemplo:
MiPunto p3 =p2;
Aunque tan sólo se creó un objeto MiPunto, hay dos variables (p2 y p3) que lo
referencian. Cualquier cambio realizado en el objeto referenciado por p2 afectará al
objeto referenciado por p3. La asignación de p2 a p3 no reserva memoria ni modifica el
objeto.
De hecho, las asignaciones posteriores de p2 simplemente desengancharán p2 del
objeto, sin afectarlo:
p2 = null; // p3 todavía apunta al objeto creado con new
Aunque se haya asignado null a p2, p3 todavía apunta al objeto creado por el operador
new.
Cuando ya no haya ninguna variable que haga referencia a un objeto, Java reclama
automáticamente la memoria utilizada por ese objeto, a lo que se denomina recogiaa ae
basura.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 67 de 189
Cuando se realiza una instancia de una clase (mediante new) se reserva en la memoria
un espacio para un conjunto de datos como el que definen los atributos de la clase que
se indica en la instanciación. A este conjunto de variables se le denomina variables ae
instancia.
La potencia de las variables de instancia es que se obtiene un conjunto distinto de ellas
cada vez que se crea un objeto nuevo. Es importante el comprender que cada objeto
tiene su propia copia de las variables de instancia de su clase, por lo que los cambios
sobre las variables de instancia de un objeto no tienen efecto sobre las variables de
instancia de otro.
El siguiente programa crea dos objetos MiPunto y establece los valores de x e v de cada
uno de ellos de manera independiente para mostrar que están realmente separados.
MiPunto p4 = new MiPunto( 10, 20 );
MiPunto p5 = new MiPunto( 42, 99 );
System.out.println(“p4.- x = “ + p4.x + “ y = “ + p4.y);
System.out.println(“p5.- x = “ + p5.x + “ y = “ + p5.y);
Este es el aspecto de salida cuando lo ejecutamos.
p4.- x = 10 y = 20
p5.- x = 42 y = 99
D. ACCESO AL OBJETO
a.) El operador punto (.)
El operador punto (.) se utiliza para acceder a las variables de instancia y los métodos
contenidos en un objeto, mediante su referencia a objeto:
referencia_a_objeto.nombre_de_variable_de_instancia
referencia_a_objeto.nombre_de_método( lista-de-parámetros );
Hemos creado un ejemplo completo que combina los operadores new y punto para crear
un objeto MiPunto, almacenar algunos valores en él e imprimir sus valores finales:
MiPunto p6 = new MiPunto( 10, 20 );
System.out.println (“p6.- 1. X=“ + p6.x + “ , Y=“ + p6.y);
p6.inicia( 30, 40 );
System.out.println (“p6.- 2. X=“ + p6.x + “ , Y=“ + p6.y);
Cuando se ejecuta este programa, se observa la siguiente salida:
p6.- 1. X=10 , Y=20
p6.- 2. X=30 , Y=40
Durante las impresiones (método println()) se accede al valor de las variables mediante
p6.x y p6.v, y entre una impresión y otra se llama al método inicia(), cambiando los
valores de las variables de instancia.
Este es uno de los aspectos más importantes de la diferencia entre la programación
orientada a objetos y la programación estructurada. Cuando se llama al método
p6.inicia(), lo primero que se hace en el método es sustituir los nombres de los atributos
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 68 de 189
de la clase por las correspondientes variables de instancia del objeto con que se ha
llamado. Así por ejemplo x se convertirá en p6.x.
Si otros objetos llaman a inicia(), incluso si lo hacen de una manera concurrente, no se
producen efectos laterales, ya que las variables de instancia sobre las que trabajan son
distintas.
b.) La referencia this
Java incluye un valor de referencia especial llamado this, que se utiliza dentro de
cualquier método para referirse al objeto actual. El valor this se refiere al objeto sobre el
que ha sido llamado el método actual. Se puede utilizar this siempre que se requiera una
referencia a un objeto del tipo de una clase actual. Si hay dos objetos que utilicen el
mismo código, seleccionados a través de otras instancias, cada uno tiene su propio valor
único de this.
Un refinamiento habitual es que un constructor llame a otro para construir la instancia
correctamente. El siguiente constructor llama al constructor parametrizado MiPunto(x.v)
para terminar de iniciar la instancia:
MiPunto() {
this( -1, -1 ); // Llama al constructor parametrizado
}
En Java se permite declarar variables locales, incluyendo parámetros formales de
métodos, que se solapen con los nombres de las variables de instancia.
No se utilizan x e v como nombres de parámetro para el método inicia, porque
ocultarían las variables de instancia x e v reales del ámbito del método. Si lo hubiésemos
hecho, entonces x se hubiera referido al parámetro formal, ocultando la variable de
instancia x.
void inicia2( int x, int y ) {
x = x; // Ojo, no modificamos la variable de instancia!!!
this.y = y; // Modificamos la variable de instancia!!!
}
E. LA DESTRUCCIÓN DEL OBJETO
a.) La destrucción de los objetos
Cuando un objeto no va a ser utilizado, el espacio de memoria de dinámica que utiliza
ha de ser liberado, así como los recursos que poseía, permitiendo al programa disponer
de todos los recursos posibles. A esta acción se la da el nombre de aestruccion ael
obieto.
En Java la destrucción se puede realizar de forma automática o de forma personalizada,
en función de las características del objeto.
b.) La destrucción por defecto: Recogida de basura
El intérprete de Java posee un sistema de recogida de basura, que por lo general permite
que no nos preocupemos de liberar la memoria asignada explícitamente.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 69 de 189
El recolector de basura será el encargado de liberar una zona de memoria dinámica que
había sido reservada mediante el operador new, cuando el objeto ya no va a ser utilizado
más durante el programa (por ejemplo, sale del ámbito de utilización, o no es
referenciado nuevamente).
El sistema de recogida de basura se ejecuta periódicamente, buscando objetos que ya no
estén referenciados.
c.) La destrucción personalizada: finalize
A veces una clase mantiene un recurso que no es de Java como un descriptor de archivo
o un tipo de letra del sistema de ventanas. En este caso sería acertado el utilizar la
finalización explícita, para asegurar que dicho recurso se libera. Esto se hace mediante
la aestruccion personalizaaa, un sistema similar a los destructores de C++.
Para especificar una aestruccion personalizaaa se añade un método a la clase con el
nombre finalize.
class ClaseFinalizada{
ClaseFinalizada() { // Constructor
// Reserva del recurso no Java o recurso compartido
}
protected void finalize() {
// Liberación del recurso no Java o recurso compartido
}
}
El intérprete de Java llama al método finalize(), si existe cuando vaya a reclamar el
espacio de ese objeto, mediante la recogida de basura.
Debe observarse que el método finalize() es de tipo protectea voia y por lo tanto deberá
de sobreescribirse con este mismo tipo.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 70 de 189
II.6. LA HERENCIA
A. INTRODUCCIÓN
La verdadera potencia de la programación orientada a objetos radica en su capacidad
para reflejar la abstracción que el cerebro humano realiza automáticamente durante el
proceso de aprendizaje y el proceso de análisis de información.
Las personas percibimos la realidad como un conjunto de objetos interrelacionados.
Dichas interrelaciones, pueden verse como un conjunto de abstracciones y
generalizaciones que se han ido asimilando desde la niñez. Así, los defensores de la
programación orientada a objetos afirman que esta técnica se adecua mejor al
funcionamiento del cerebro humano, al permitir descomponer un problema de cierta
magnitud en un conjunto de problemas menores subordinados del primero.
La capacidad de descomponer un problema o concepto en un conjunto de objetos
relacionados entre sí, y cuyo comportamiento es fácilmente identificable, puede ser muy
útil para el desarrollo de programas informáticos.
B. JERARQUÍA
La herencia es el mecanismo fundamental de relación entre clases en la orientación a
objetos. Relaciona las clases de manera jerárquica; una clase paare o superclase sobre
otras clases hiias o subclases.
Imagen 4. Eiemplo ae otro arbol ae herencia
Los descendientes de una clase heredan todas las variables y métodos que sus
ascendientes hayan especificado como hereaables, además de crear los suyos propios.
La característica de herencia, nos permite definir nuevas clases derivadas de otra ya
existente, que la especializan de alguna manera. Así logramos definir una jerarquía de
clases, que se puede mostrar mediante un árbol de herencia.
En todo lenguaje orientado a objetos existe una jerarquía, mediante la que las clases se
relacionan en términos de herencia. En Java, el punto más alto de la jerarquía es la clase
Obiect de la cual derivan todas las demás clases.
C. HERENCIA MÚLTIPLE
En la orientación a objetos, se consideran dos tipos de herencia, simple y múltiple. En el
caso de la primera, una clase sólo puede derivar de una única superclase. Para el
segundo tipo, una clase puede descender de varias superclases.
Clase Hija1 Clase Hija2
Clase Padre
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 71 de 189
En Java sólo se dispone de herencia simple, para una mayor sencillez del lenguaje, si
bien se compensa de cierta manera la inexistencia de herencia múltiple con un concepto
denominado interface, que estudiaremos más adelante.
D. DECLARACIÓN
Para indicar que una clase deriva de otra, heredando sus propiedades (métodos y
atributos), se usa el término extenas, como en el siguiente ejemplo:
public class SubClase extends SuperClase {
// Contenido de la clase
}
Por ejemplo, creamos una clase MiPunto3D, hija de la clase ya mostrada MiPunto:
class MiPunto3D extends MiPunto {
int z;
MiPunto3D( ) {
x = 0; // Heredado de MiPunto
y = 0; // Heredado de MiPunto
z = 0; // Nuevo atributo
}
}
La palabra clave extenas se utiliza para decir que deseamos crear una subclase de la
clase que es nombrada a continuación, en nuestro caso MiPunto3D es hija de MiPunto.
E. LIMITACIONES EN LA HERENCIA
Todos los campos y métodos de una clase son siempre accesibles para el código de la
misma clase.
Para controlar el acceso desde otras clases, y para controlar la herencia por las subclase,
los miembros (atributos y métodos) de las clases tienen tres modificadores posibles de
control de acceso:
Πpublic: Los miembros declarados public son accesibles en cualquier lugar en que sea
accesible la clase, y son heredados por las subclases.
Œ private: Los miembros declarados private son accesibles sólo en la propia clase.
Œ protectea: Los miembros declarados protectea son accesibles sólo para sus
subclases
Por ejemplo:
class Padre { // Hereda de Object
// Atributos
private int numeroFavorito, nacidoHace, dineroDisponible;
// Métodos
public int getApuesta() {
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 72 de 189
return numeroFavorito;
}
protected int getEdad() {
return nacidoHace;
}
private int getSaldo() {
return dineroDisponible;
}
}
class Hija extends Padre {
// Definición
}
class Visita {
// Definición
}
En este ejemplo, un objeto de la clase Hiia, hereda los tres atributos (numeroFavorito,
naciaoHace y aineroDisponible) y los tres métodos ( getApuesta(), getEaaa() y
getSalao() ) de la clase Paare, y podrá invocarlos. Cuando se llame al método
getEaaa() de un objeto de la clase Hiia, se devolverá el valor de la variable de instancia
naciaoHace de ese objeto, y no de uno de la clase Paare.
Sin embargo, un objeto de la clase Hiia, no podrá invocar al método getSalao() de un
objeto de la clase Paare, con lo que se evita que el Hiio conozca el estado de la cuenta
corriente de un Paare.
La clase Jisita, solo podrá acceder al método getApuesta(), para averiguar el número
favorito de un Paare, pero de ninguna manera podrá conocer ni su saldo, ni su edad
(sería una indiscreción, ¿no?).
F. LA CLASE OBJECT
La clase Obiect es la superclase de todas las clases da Java. Todas las clases derivan,
directa o indirectamente de ella. Si al definir una nueva clase, no aparece la cláusula
extenas, Java considera que dicha clase desciende directamente de Obiect.
La clase Obiect aporta una serie de funciones básicas comunes a todas las clases:
Πpublic boolean equals( Obiect obi ): Se utiliza para comparar, en valor, dos objetos.
Devuelve true si el objeto que recibe por parámetro es igual, en valor, que el objeto
desde el que se llama al método. Si se desean comparar dos referencias a objeto se
pueden utilizar los operadores de comparación == y !=.
Œ public int hashCoae(): Devuelve un código hash para ese objeto, para poder
almacenarlo en una Hashtable.
Πprotectea Obiect clone() throws CloneNotSupporteaException. Devuelve una copia
de ese objeto.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 73 de 189
Πpublic final Class getClass(): Devuelve el objeto concreto, de tipo Class, que
representa la clase de ese objeto.
Πprotectea voia finalize() throws Trowable: Realiza acciones durante la recogida de
basura.
Para más información véase }Arnold y Gosling, 1997].
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 74 de 189
II.7. OPERACIONES AVANZADAS EN LAS CLASES
A. INTRODUCCIÓN
La programación orientada a objetos en Java va mucho más allá de las clases, los
objetos y la herencia. Java presenta una serie de capacidades que enriquecen el modelo
de objetos que se puede representar en un programa Java. En este capítulo entraremos
en ellos.
Vamos a ver cómo programar conceptos avanzados de la herencia, polimorfismo y
composición, como conceptos que se pueden programar en Java.
B. OPERACIONES AVANZADAS EN LA HERENCIA
a.) Introducción
En el capítulo anterior ya se han estudiado los fundamentos de la herencia en Java. Sin
embargo, el lenguaje tiene muchas más posibilidades en este aspecto, como
estudiaremos a continuación.
Conviene recordar que estamos utilizando el código de la clase MiPunto, cuyo código se
puede encontrar en el apartado 'II.5. Clases v Obietos` de este tutorial.
b.) Los elementos globales: static
A veces se desea crear un método o una variable que se utiliza fuera del contexto de
cualquier instancia, es decir, de una manera global a un programa. Todo lo que se tiene
que hacer es declarar estos elementos como static.
Esta es la manera que tiene Java de implementar funciones y variables globales.
Por ejemplo:
static int a = 3;
static void metodoGlobal() {
// implementación del método
}
No se puede hacer referencia a this o a super dentro de una método static.
Mediante atributos estáticos, todas las instancias de una clase además del espacio propio
para variables de instancia, comparten un espacio común. Esto es útil para modelizar
casos de la vida real.
Otro aspecto en el que es útil static es en la creación de métodos a los que se puede
llamar directamente diciendo el nombre de la clase en la que están declarados. Se puede
llamar a cualquier método static, o referirse a cualquier variable static. utilizando el
operador punto con el nombre de la clase, sin necesidad de crear un objeto de ese tipo:
class ClaseStatic {
int atribNoStatic = 42;
static int atribStatic = 99;
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 75 de 189
static void metodoStatic() {
System.out.println(“Met. static = “ + atribStatic);
}
static void metodoNoStatic() {
System.out.println(“Met. no static = “ + atribNoStatic);
}
}
El siguiente código es capaz de llamar a metoaoStatic y atribStatic nombrando
directamente la clase (sin objeto, sin new), por haber sido declarados static.
System.out.println(“At. static = “ + ClaseStatic.atribStatic);
ClaseStatic.metodoStatic(); // Sin instancia
new ClaseStatic().metodoNoStatic(); // Hace falta instancia
Si ejecutamos este programa obtendríamos:
At. static = 99
Met. static = 99
Met. no static = 42
Debe tenerse en cuenta que en un método estático tan sólo puede hacerse refernecia a
variables estáticas.
c.) Las clases y métodos abstractos: abstract
Hay situaciones en las que se necesita definir una clase que represente un concepto
abstracto, y por lo tanto no se pueda proporcionar una implementación completa de
algunos de sus métodos.
Se puede declarar que ciertos métodos han de ser sobrescritos en las subclases,
utilizando el modificador de tipo abstract. A estos métodos también se les llama
responsabiliaaa ae subclase. Cualquier subclase de una clase abstract debe
implementar todos los métodos abstract de la superclase o bien ser declarada también
como abstract.
Cualquier clase que contenga métodos declarados como abstract también se tiene que
declarar como abstract, y no se podrán crear instancias de dicha clase (operador new).
Por último se pueden declarar constructores abstract o métodos abstract static.
Veamos un ejemplo de clases abstractas:
abstract class claseA {
abstract void metodoAbstracto();
void metodoConcreto() {
System.out.println(“En el metodo concreto de claseA”);
}
}
class claseB extends claseA {
void metodoAbstracto(){
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 76 de 189
System.out.println(“En el metodo abstracto de claseB”);
}
}
La clase abstracta claseA ha implementado el método concreto metoaoConcreto(), pero
el método metoaoAbstracto() era abstracto y por eso ha tenido que ser redefinido en la
clase hija claseB.
claseA referenciaA = new claseB();
referenciaA.metodoAbstracto();
referenciaA.metodoConcreto();
La salida de la ejecución del programa es:
En el metodo abstracto de claseB
En el metodo concreto de claseA
C. EL POLIMORFISMO
a.) Selección dinámica de método
Las dos clases implementadas a continuación tienen una relación subclase/superclase
simple con un único método que se sobrescribe en la subclase:
class claseAA {
void metodoDinamico() {
System.out.println(“En el metodo dinamico de claseAA”);
}
}
class claseBB extends claseAA {
void metodoDinamico() {
System.out.println(“En el metodo dinamico de claseBB”);
}
}
Por lo tanto si ejecutamos:
claseAA referenciaAA = new claseBB();
referenciaAA.metodoDinamico();
La salida de este programa es:
En el metodo dinamico de claseBB
Se declara la variable de tipo claseA, y después se almacena una referencia a una
instancia de la clase claseB en ella. Al llamar al método metoaoDinamico() de claseA, el
compilador de Java verifica que claseA tiene un método llamado metoaoDinamico(),
pero el intérprete de Java observa que la referencia es realmente una instancia de
claseB, por lo que llama al método metoaoDinamico() de claseB en vez de al de claseA.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 77 de 189
Esta forma de polimorfismo ainamico en tiempo ae eiecucion es uno de los mecanismos
más poderosos que ofrece el diseño orientado a objetos para soportar la reutilización del
código y la robustez.
b.) Sobrescritura de un método
Durante una jerarquía de herencia puede interesar volver a escribir el cuerpo de un
método, para realizar una funcionalidad de diferente manera dependiendo del nivel de
abstracción en que nos encontremos. A esta modificación de funcionalidad se le llama
sobrescritura de un método.
Por ejemplo, en una herencia entre una clase SerJivo y una clase hija Persona; si la
clase SerJivo tuviese un método alimentarse(), debería volver a escribirse en el nivel de
Persona, puesto que una persona no se alimenta ni como un Animal, ni como una
Planta...
La mejor manera de observar la diferencia entre sobrescritura y sobrecarga es mediante
un ejemplo. A continuación se puede observar la implementación de la sobrecarga de la
distancia en 3D y la sobrescritura de la distancia en 2D.
class MiPunto3D extends MiPunto {
int x,y,z;
double distancia(int pX, int pY) { // Sobrescritura
int retorno=0;
retorno += ((x/z)-pX)*((x/z)-pX);
retorno += ((y/z)-pY)*((y/z)-pY);
return Math.sqrt( retorno );
}
}
Se inician los objetos mediante las sentencias:
MiPunto p3 = new MiPunto(1,1);
MiPunto p4 = new MiPunto3D(2,2);
Y llamando a los métodos de la siguiente forma:
p3.distancia(3,3); //Método MiPunto.distancia(pX,pY)
p4.distancia(4,4); //Método MiPunto3D.distancia(pX,pY)
Los métodos se seleccionan en función del tipo de la instancia en tiempo de ejecución,
no a la clase en la cual se está ejecutando el método actual. A esto se le llama seleccion
ainamica ae metoao.
c.) Sobrecarga de método
Es posible que necesitemos crear más de un método con el mismo nombre, pero con
listas de parámetros distintas. A esto se le llama sobrecarga ael metoao. La sobrecarga
de método se utiliza para proporcionar a Java un comportamiento polimorfico.
Un ejemplo de uso de la sobrecarga es por ejemplo, el crear constructores alternativos
en función de las coordenadas, tal y como se hacía en la clase MiPunto:
MiPunto( ) { //Constructor por defecto
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 78 de 189
inicia( -1, -1 );
}
MiPunto( int paramX, int paramY ) { // Parametrizado
this.x = paramX;
y = paramY;
}
Se llama a los constructores basándose en el número y tipo de parámetros que se les
pase. Al número de parámetros con tipo de una secuencia específica se le llama
signatura ae tipo. Java utiliza estas signaturas de tipo para decidir a qué método llamar.
Para distinguir entre dos métodos, no se consideran los nombres de los parámetros
formales sino sus tipos:
MiPunto p1 = new MiPunto(); // Constructor por defecto
MiPunto p2 = new MiPunto( 5, 6 ); // Constructor parametrizado
d.) Limitación de la sobreescritura: final
Todos los métodos y las variables de instancia se pueden sobrescribir por defecto. Si se
desea declarar que ya no se quiere permitir que las subclases sobrescriban las variables
o métodos, éstos se pueden declarar como final. Esto se utiliza a menudo para crear el
equivalente de una constante de C++.
Es un convenio de codificación habitual elegir identificadores en mayúsculas para las
variables que sean final. por ejemplo:
final int NUEVO_ARCHIVO = 1;
D. LAS REFERENCIAS POLIMÓRFICAS: THIS Y SUPER
b.) Acceso a la propia clase: this
Aunque ya se explicó en el apartado "II.5. Clases v obietos" de este tutorial el uso de la
referencia this como modificador de ámbito, también se la puede nombrar como
ejemplo de polimorfismo
Además de hacer continua referencia a la clase en la que se invoque, también vale para
sustituir a sus constructores, utilizándola como método:
this(); // Constructor por defecto
this( int paramX, int paramY ); // Constructor parametrizado
b.) Acceso a la superclase: super
Ya hemos visto el funcionamiento de la referencia this como referencia de un objeto
hacia sí mismo. En Java existe otra referencia llamada super, que se refiere
directamente a la superclase.
La referencia super usa para acceder a métodos o atributos de la superclase.
Podíamos haber implementado el constructor de la clase MiPunto3D (hija de MiPunto)
de la siguiente forma:
MiPunto3D( int x, int y, int z ) {
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 79 de 189
super( x, y ); // Aquí se llama al constructor de MiPunto
this.z = super.metodoSuma( x, y ); // Método de la superclase
}
Con una sentencia super.metoaoSuma(x. v) se llamaría al método metoaoSuma() de la
superclase de la instancia this. Por el contrario con super() llamamos al constructor de la
superclase.
E. LA COMPOSICIÓN
Otro tipo de relación muy habitual en los diseños de los programas es la composición.
Los objetos suelen estar compuestos de conjuntos de objetos más pequeños; un coche es
un conjunto de motor y carrocería, un motor es un conjunto de piezas, y así
sucesivamente. Este concepto es lo que se conoce como composicion.
La forma de implementar una relación de composición en Java es incluyendo una
referencia a objeto de la clase componedora en la clase compuesta.
Por ejemplo, una clase AreaRectangular, quedaría definida por dos objetos de la clase
MiPunto, que representasen dos puntas contrarias de un rectángulo:
class AreaRectangular {
MiPunto extremo1; //extremo inferior izquierdo
MiPunto extremo2; //extremo superior derecho
AreaRectangular() {
extremo1=new MiPunto();
extremo2=new MiPunto();
}
boolean estaEnElArea( MiPunto p ){
if ( ( p.x>=extremo1.x && p.x<=extremo2.x ) &&
( p.y>=extremo1.y && p.y<=extremo2.y ) )
return true;
else
return false;
}
}
Puede observarse que las referencias a objeto (extremo1 y extremo2) son iniciadas,
instanciando un objeto para cada una en el constructor. Así esta clase mediante dos
puntos, referenciados por extremo1 y extremo2, establece unos límites de su área, que
serán utilizados para comprobar si un punto está en su área en el método
estaEnElArea().
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 80 de 189
II.8. GESTIÓN DE EXCEPCIONES Y ERRORES
A. INTRODUCCIÓN
El control de flujo en un programa Java puede hacerse mediante las ya conocidas
sentencias estructuradas (if. while. return). Pero Java va mucho más allá, mediante una
técnica de programación denominada gestion ae excepciones.
Mediante las excepciones se podrá evitar repetir continuamente código, en busca de un
posible error, y avisar a otros objetos de una condición anormal de ejecución durante un
programa.
Durante este capítulo estudiaremos la gestión de excepciones y errores, sin pretender
profundizar demasiado, pero sí fijando la base conceptual de lo que este modo de
programación supone.
Mediante la gestión de excepciones se prescindirá de sentencias de control de errores
del tipo:
if ( error == true )
return ERROR;
B. TIPOS DE EXCEPCIONES
Existen varios tipos fundamentales de excepciones:
ΠError: Excepciones que indican problemas muy graves, que suelen ser no
recuperables y no deben casi nunca ser capturadas.
ΠException: Excepciones no definitivas, pero que se detectan fuera del tiempo de
ejecución.
Œ RuntimeException: Excepciones que se dan durante la ejecución del programa.
Imagen 5. Herencia ae excepciones Java
Todas las excepciones tienen como clase base la clase Throwable, que está incluida en
el paquete iava.lang, y sus métodos son:
ΠTrowable( String mensaie ), Constructor. La cadena es opcional
Œ Throwable fillInStackTrace(), Llena la pila de traza de ejecución.
Œ String getLocalizeaMessage(), Crea una descripción local de este objeto.
Clases de Exception
Clases de RuntimeException
RuntimeException
Exception
Clases de Error
Error
Throwable
Object
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 81 de 189
ΠString getMessage(), Devuelve la cadena de error del objeto.
Πvoia printStackTrace(PrintStreamoPrintWriter s), Imprime este objeto y su traza
en el flujo del parámetro s, o en la salida estándar (por defecto).
Œ String toString(), Devuelve una breve descripción del objeto.
C. FUNCIONAMIENTO
a.) Introducción
Para que el sistema de gestión de excepciones funcione, se ha de trabajar en dos partes
de los programas:
Œ Definir qué partes de los programas crean una excepción y bajo qué condiciones.
Para ello se utilizan las palabras reservadas throw y throws.
Œ Comprobar en ciertas partes de los programas si una excepción se ha producido, y
actuar en consecuencia. Para ello se utilizan las palabras reservadas try, catch y
finally.
b.) Manejo de excepciones: try - catch - finally
Cuando el programador va a ejecutar un trozo de código que pueda provocar una
excepción (por ejemplo, una lectura en un fichero), debe incluir este fragmento de
código dentro de un bloque trv:
try {
// Código posiblemente problemático
}
Pero lo importante es cómo controlar qué hacer con la posible excepción que se cree.
Para ello se utilizan las clausulas catch, en las que se especifica que acción realizar:
try {
// Código posiblemente problemático
} catch( tipo_de_excepcion e) {
// Código para solucionar la excepción e
} catch( tipo_de_excepcion_mas_general e) {
// Código para solucionar la excepción e
}
En el ejemplo se observa que se pueden anidar sentencias catch, pero conviene hacerlo
indicando en último lugar las excepciones más generales (es decir, que se encuentren
más arriba en el árbol de herencia de excepciones), porque el intérprete Java ejecutará
aquel bloque de código catch cuyo parámetro sea del tipo de una excepción lanzada.
Si por ejemplo se intentase capturar primero una excepción Throwable, nunca
llegaríamos a gestionar una excepción Runtime, puesto que cualquier clase hija de
Runtime es también hija de Throwable, por herencia.
Si no se ha lanzado ninguna excepción el código continúa sin ejecutar ninguna sentencia
catch.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 82 de 189
Pero, ¿y si quiero realizar una acción común a todas las opciones?. Para insertar
fragmentos de código que se ejecuten tras la gestión de las excepciones. Este código se
ejecutará tanto si se ha tratado una excepción (catch) como sino. Este tipo de código se
inserta en una sentencia finallv, que será ejecutada tras el bloque trv o catch.
try {
} catch( Exception e ) {
} finally {
// Se ejecutara tras try o catch
}
c.) Lanzamiento de excepciones: throw - throws
Muchas veces el programador dentro de un determinado método deberá comprobar si
alguna condición de excepción se cumple, y si es así lanzarla. Para ello se utilizan las
palabras reservadas throw y throws.
Por una parte la excepción se lanza mediante la sentencia throw:
if ( condicion_de_excepcion == true )
throw new miExcepcion();
Se puede observar que hemos creado un objeto de la clase miExcepcion, puesto que las
excepciones son objetos y por tanto deberán ser instanciadas antes de ser lanzadas.
Aquellos métodos que pueden lanzar excepciones, deben cuáles son esas excepciones en
su declaración. Para ello se utiliza la sentencia throws:
tipo_devuelto miMetodoLanzador() throws miExcep1, miExcep2 {
// Codigo capaz de lanzar excepciones miExcep1 y miExcep2
}
Se puede observar que cuando se pueden lanzar en el método más de una excepción se
deben indicar en su declaración separadas por comas.
d.) Ejemplo de gestión de excepciones
Ahora que ya sabemos cómo funciona este sistema, conviene ver al menos un pequeño
ejemplo, que ilustre al lector en el uso de las excepciones:
// Creo una excepción personalizada
class MiExcepcion extends Exception {
MiExcepcion(){
super(); // constructor por defecto de Exception
}
MiExcepcion( String cadena ){
super( cadena ); // constructor param. de Exception
}
}
// Esta clase lanzará la excepción
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 83 de 189
class Lanzadora {
void lanzaSiNegativo( int param ) throws MiExcepcion {
if ( param < 0 )
throw new MiExcepcion( "Numero negativo" );
}
}
class Excepciones {
public static void main( String[] args ) {
// Para leer un fichero
Lanzadora lanza = new Lanzadora();
FileInputStream entrada = null;
int leo;
try {
entrada = new FileInputStream( "fich.txt" );
while ( ( leo = entrada.read() ) != -1 )
lanza.lanzaSiNegativo( leo );
entrada.close();
System.out.println( "Todo fue bien" );
} catch ( MiExcepcion e ){ // Personalizada
System.out.println( "Excepcion: " + e.getMessage() );
} catch ( IOException e ){ // Estándar
System.out.println( "Excepcion: " + e.getMessage() );
} finally {
if ( entrada != null )
try {
entrada.close(); // Siempre queda cerrado
} catch ( Exception e ) {
System.out.println( "Excepcion: " + e.getMessage() );
}
System.out.println( "Fichero cerrado." );
}
}
}
class Excepciones {
public static void main( String[] args ) {
// Para leer un fichero
FileInputStream entrada = null;
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 84 de 189
Lanzadora lanza = new Lanzadora();
int leo;
try {
entrada = new FileInputStream("fich.txt");
while ( ( leo = entrada.read() ) != -1 )
lanza.lanzaSiNegativo( leo );
System.out.println( "Todo fue bien" );
} catch ( MiExcepcion e ){ // Personalizada
System.out.println( "Excepcion: " + e.getMessage() );
} catch ( IOException e ){ // Estándar
System.out.println( "Excepcion: " + e.getMessage() );
} finally {
entrada.close(); // Así el fichero siempre queda cerrado
System.out.println( "Fichero cerrado" );
}
}
}
Este programa lee un fichero (fichero.txt), y lee su contenido en forma de números.
Si alguno de los números leídos es negativo, lanza una excepción MiExcepcion,
Además gestiona la excepción IOException, que es una excepción de las que Java
incluye y que se lanza si hay algún problema en una operación de entrada/salida.
Ambas excepciones son gestionadas, imprimiendo su contenido (cadena de error) por
pantalla.
La salida de este programa, suponiendo un número negativo sería:
Excepcion: Numero negativo
Fichero cerrado
En el caso de que no hubiera ningún número negativo sería:
Todo fue bien
Fichero cerrado
En el caso de que se produjese un error de E/S, al leer el primer número, sería:
Excepcion: java.io.IOException
Fichero cerrado
e.) Conclusiones
En cualquier caso se recomienda al programador no abusar de este sistema como control
de flujos simples, sino utilizarlo sólo en aquellos estados del programa que realmente
creen un problema de ejecución que pueda ser letal para el programa.
Para más información sobre las excepciones Java, véanse }Zolli, 1997] y }Naughton,
1996].
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 85 de 189
D. EXCEPCIONES QUE INCORPORA JAVA 1.2
a.) Clases de Error
LinkageError: Una clase no satisface la dependencia que tiene respecto a otra.
Œ ClassCircularitvError: Se detectó una herencia circular entre clases.
ΠClassFormatError: Una clase cargada no ha sido incompletamente descrita.
Œ UnsupporteaClassJersionError: La versión de una clase no es correcta.
ΠExceptionInInitializerError: Error al iniciar un miembro static.
ΠIncompatibleClassChangeError: En una clase, su interfaz no es igual al declarado
Œ AbstractMethoaError: Se ha invocado un método abstracto.
Œ IllegalAccessError: La aplicación intentó acceder a algún miembro no visible.
Œ InstantiationError: Se intentó instanciar una clase abstracta o interfaz.
Œ NoSuchFielaError: No se encontró determinado atributo.
Œ NoSuchMethoaError: No se encontró determinado método.
Œ NoClassDefFounaError: No se encontró una clase cuando se necesitaba.
Œ UnsatisfieaLinkError: Se encontró un enlace insatisfecho en un método nativo.
Œ JerifvError: Se ha producido un error de verificación al cargar una clase.
ThreaaDeath: Se ha lanzado en el threaa víctima tras llamar a stop().
JirtualMachineError: La máquina virtual se ha averiado o quedado sin recursos.
Œ InternalError: Error interno en tiempo de ejecución.
ΠOutOfMemorvError: El lector ha agotado la memoria.
Œ StackOverflowError: Desbordamiento de pila. ¿Recursión infinita?.
ΠUnknownError: Grave error desconocido.
b.) Clases de Exception
CloneNotSupporteaException: No se pudo copiar un objeto mediante clone().
IllegalAccessException: Algún método invocado es no visible.
InstantiationException: Se ha intentado instanciar una interfaz o una clase abstracta.
InterrupteaException: Cuando se invoca a interrupt() sobre un threaa dormido.
NoSuchFielaException: La clase no tiene un atributo con ese nombre.
NoSuchMethoaException: La clase no tiene un método con ese nombre.
c.) Clases de RuntimeException
ArithmeticException: Error de cálculo (como división por cero...).
ArravStoreException: Intento de almacenar un objeto equivocado en un vector.
ClassCastException: Intento de conversión inválida.
IllegalArgumentException: Se ha pasado un argumento inválido a un método:
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 86 de 189
ΠIllegalThreaaStateException: Un thread no estaba en el estado adecuado.
Œ NumberFormatException: Una cadena contenedora de un número, no lo contiene.
IllegalMonitorStateException: Se ha usado wait/notifv fuera de código sincronizado.
IllegalStateException: Método invocado en un momento inapropiado.
InaexOutOfBounasException: Acceso a un vector fuera de sus límites:
ΠArravInaexOutOfBounasException: Idem, para una matriz.
ΠStringInaexOutOfBounasException: Idem, para una cadena.
NegativeArravSizeException: Intento de creación de un vector de tamaño negativo.
NullPointerException: Se ha usado una referencia null para acceder a un campo.
SecuritvException: Algo ha sido vedado por el sistema de seguridad.
UnsupporteaOperationException: Una operación invocada no se soporta.
Para más información véase la documentación del JDK que usted vaya a utilizar.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 87 de 189
II.9. INTERFACES
A. INTRODUCCIÓN
Las interfaces Java son expresiones puras de diseño. Se trata de auténticas
conceptualizaciones no implementadas que sirven de guía para definir un determinado
concepto (clase) y lo que debe hacer, pero sin desarrollar un mecanismo de solución.
Se trata de declarar métodos abstractos y constantes que posteriormente puedan ser
implementados de diferentes maneras según las necesidades de un programa.
Por ejemplo una misma interfaz podría ser implementada en una versión de prueba de
manera poco óptima, y ser acelerada convenientemente en la versión definitiva tras
conocer más a fondo el problema.
B. DECLARACIÓN
Para declarar una interfaz se utiliza la sentencia interface, de la misma manera que se
usa la sentencia class:
interface MiInterfaz {
int CONSTANTE = 100;
int metodoAbstracto( int parametro );
}
Se observa en la declaración que las variables adoptan la declaración en mayúsculas,
pues en realidad actuarán como constantes final. En ningún caso estas variables
actuarán como variables de instancia.
Por su parte, los métodos tras su declaración presentan un punto y coma, en lugar de su
cuerpo entre llaves. Son métodos abstractos, por tanto, métodos sin implementación
C. IMPLEMENTACIÓN DE UNA INTERFAZ
Como ya se ha visto, las interfaces carecen de funcionalidad por no estar implementados
sus métodos, por lo que se necesita algún mecanismo para dar cuerpo a sus métodos.
La palabra reservada implements utilizada en la declaración de una clase indica que la
clase implementa la interfaz, es decir, que asume las constantes de la interfaz, y codifica
sus métodos:
class ImplementaInterfaz implements MiInterfaz{
int multiplicando=CONSTANTE;
int metodoAbstracto( int parametro ){
return ( parametro * multiplicando );
}
}
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 88 de 189
En este ejemplo se observa que han de codificarse todos los métodos que determina la
interfaz (metoaoAbstracto()), y la validez de las constantes (CONSTANTE) que define
la interfaz durante toda la declaración de la clase.
Una interfaz no puede implementar otra interfaz, aunque sí extenderla (extenas)
ampliándola.
D. HERENCIA MÚLTIPLE
Java es un lenguaje que incorpora herencia simple de implementación pero que puede
aportar herencia múltiple de interfaz. Esto posibilita la herencia múltiple en el diseño de
los programas Java.
Una interfaz puede heredar de más de una interfaz antecesora.
interface InterfazMultiple extends Interfaz1,Interfaz2{ }
Una clase no puede tener más que una clase antecesora, pero puede implementar más de
una interfaz:
class MiClase extends SuPadre implements Interfaz1,Interfaz2{ }
El ejemplo típico de herencia múltiple es el que se presenta con la herencia en diamante:
Imagen 6. Eiemplo ae herencia multiple
Para poder llevar a cabo un esquema como el anterior en Java es necesario que las
clases A, B y C de la figura sean interfaces, y que la clase D sea una clase (que recibe la
herencia múltiple):
interface A{ }
interface B extends A{ }
interface C extends A{ }
class D implements B,C{ }
E. COLISIONES EN LA HERENCIA MÚLTIPLE
En una herencia múltiple, los identificadores de algunos métodos o atributos pueden
coincidir en la clase que hereda, si dos de las interfaces padres tienen algún método o
atributo que coincida en nombre. A esto se le llama colision.
Esto se dará cuando las clases padre (en el ejemplo anterior B y C) tienen un atributo o
método que se llame igual. Java resuelve el problema estableciendo una serie de reglas.
Para la colisión de nombres de atributos, se obliga a especificar a qué interfaz base
pertenecen al utilizarlos.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 89 de 189
Para la colisión de nombres en métodos:
Œ Si tienen el mismo nombre y diferentes parámetros: se produce sobrecarga de
métodos permitiendo que existan varias maneras de llamar al mismo.
Œ Si sólo cambia el valor devuelto: se da un error de compilación, indicando que no se
pueden implementar los dos.
Œ Si coinciden en su declaración: se elimina uno de los dos, con lo que sólo queda
uno.
F. ENVOLTURAS DE LOS TIPOS SIMPLES
Los tipos de datos de Java no forman parte de la jerarquía de objetos. Sin embargo a
veces es necesario crear una representación como objeto de alguno de los tipos de datos
simples de Java.
La API de Java contiene un conjunto de interfaces especiales para modificar el
comportamiento de los tipos de datos simple. A estas interfaces se las conoce como
envolturas ae tipo simple.
Todas ellas son hijas de la clase abstracta Number y son:
ΠDouble: Da soporte al tipo double.
ΠFloat: Da soporte al tipo float.
ΠInteger: Da soporte a los tipos int, short y byte.
ΠLong: Da soporte al tipo long.
ΠCharacter: Envoltura del tipo char.
ΠBoolean: Envoltorio al tipo boolean.
Para más información sobre as envolturas de tipos simples, consúltese }Naughton,
1996].
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 90 de 189
II.10. PAQUETES
A. INTRODUCCIÓN
Los paquetes son el mecanismo por el que Java permite agrupar clases, interfaces,
excepciones y constantes. De esta forma, se agrupan conjuntos de estructuras de datos y
de clases con algún tipo de relación en común.
Con la idea de mantener la reutilización y facilidad de uso de los paquetes desarrollados
es conveniente que las clases e interfaces contenidas en los mismos tengan cierta
relación funcional. De esta manera los desarrolladores ya tendrán una idea de lo que
están buscando y fácilmente sabrán qué pueden encontrar dentro de un paquete.
B. CREACIÓN DE UN PAQUETE
a.) Declaración
Para declarar un paquete se utiliza la sentencia package seguida del nombre del paquete
que estemos creando:
package NombrePaquete;
La estructura que ha de seguir un fichero fuente en Java es:
Œ Una única sentencia de paquete (opcional).
Œ Las sentencias de importación deseadas (opcional).
Œ La declaración de una (y sólo una) clase pública (public).
ΠLas clases privadas del paquete (opcional).
Por lo tanto la sentencia de declaración de paquete ha de ser la primera en un archivo
fuente Java.
b.) Nomenclatura
Para que los nombres de paquete puedan ser fácilmente reutilizados en toda una
compañía o incluso en todo el mundo es conveniente darles nombres únicos. Esto puede
ser una tarea realmente tediosa dentro de una gran empresa, y absolutamente imposible
dentro de la comunidad de Internet.
Por eso se propone asignar como paquetes y subpaquetes el nombre de dominio dentro
de Internet. Se verá un ejemplo para un dominio que se llamase iapon.magic.com. un
nombre apropiado sería com.magic.iapon.paquete.
c.) Subpaquetes
Cada paquete puede tener a su vez paquetes con contenidos parecidos, de forma que un
programador probablemente estará interesado en organizar sus paquetes de forma
jerárquica. Para eso se definen los subpaquetes.
Para crear un subpaquete bastará con almacenar el paquete hijo en un directorio
Paquete/Subpaquete.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 91 de 189
Así una clase dentro de un subpaquete como Paquete.Subpaquete.clase estará
codificada en el fichero Paquete/Subpaquete.iava.
El JDK define una variable de entorno denominada CLASSPATH que gestiona las rutas
en las que el JDK busca los subpaquetes. El directorio actual suele estar siempre
incluido en la variable de entorno CLASSPATH.
Para más información sobre el JDK véase el "Apenaice I. JDK" de este tutorial.
C. USO DE UN PAQUETE
Con el fin de importar paquetes ya desarrollados se utiliza la sentencia import seguida
del nombre de paquete o paquetes a importar.
Se pueden importar todos los elementos de un paquete o sólo algunos.
Para importar todas las clases e interfaces de un paquete se utiliza el metacaracter ':
import PaquetePrueba.*;
También existe la posibilidad de que se deseen importar sólo algunas de las clases de un
cierto paquete o subpaquete:
import Paquete.Subpaquete1.Subpaquete2.Clase1;
Para acceder a los elementos de un paquete, no es necesario importar explícitamente el
paquete en que aparecen, sino que basta con referenciar el elemento tras una
especificación completa de la ruta de paquetes y subpaquetes en que se encuentra.
Paquete.Subpaquetes1.Subpaquete2.Clase_o_Interfaz.elemento
En la API de Java se incluyen un conjunto de paquetes ya desarrollados que se pueden
incluir en cualquier aplicación (o applet) Java que se desarrolle. Estos paquetes son
explicados con más detalle en el capítulo "III.1.Bibliotecas ae la API ae Java" de este
tutorial.
D. ÁMBITO DE LOS ELEMENTOS DE UN PAQUETE
Al introducir el concepto de paquete, surge la duda de cómo proteger los elementos de
una clase, qué visibilidad presentan respecto al resto de elementos del paquete, respecto
a los de otros paquetes...
Ya en la herencia se vieron los identificadores de visibilidad public (visible a todas las
clases), private (no visible más que para la propia clase), y protectea (visible a clases
hijas).
Por defecto se considera los elementos (clases, variables y métodos) de un mismo
paquete como visibles entre ellos (supliendo las denominadas clases amigas de C++).
Situación del elemento private sin modificador protected public
En la misma clase Sí Sí Sí Sí
En una clase
en el mismo paquete
No Sí Sí Sí
En una clase hija
en otro paquete
No No Sí Sí
En una clase no hija
en otro paquete
No No No Sí
Tabla 19. Jisibiliaaa aentro ae un paquete
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 92 de 189
Todas las reglas explicadas en este apartado son igualmente válidas para las interfaces
Java.
Para más información véase }Naughton, 1996].
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 93 de 189
II.11. LOS THREADS O PROGRAMACIÓN MULTIHILO
A. INTRODUCCIÓN
Durante la ejecución de los programas existen muchas operaciones que precisan de una
espera; en busca de una interacción con el exterior, dejando pasar el tiempo, esperando a
que otro proceso acabe...
Java permite que estos tiempos desaprovechados sean utilizados por el programador
para realizar determinadas tareas, y así aprovechar el microprocesador durante toda la
ejecución del programa. Para ello implementa el concepto de threaas, o hilos de control
del programa.
Mediante el uso de varios threaas, se consigue ejecutar varios procesos en paralelo, de
forma que cuando uno de ellos esté esperando algún evento, permita que el
microprocesador ejecute alguno de los otros threaas en espera. Cuando el evento que el
primer threaa esperaba sucede, de nuevo se intercambian los threaas para que el primer
threaa continúe su ejecución.
Todo esto viene a suplir a la técnica de exclusión mutua denominada utilizacion ae
semaforos, extendida entre los programadores de C en UNIX.
B. UTILIZACIÓN DE THREAD
Para crear un threaa, se ha de implementar una clase, extendiendo la clase base
Runnable, y crear un objeto de la clase Threaa. Este objeto representará un nuevo hilo
de control, que será accionado cuando invoquemos al método start() del threaa. En ese
momento este hilo se activará, ejecutando (si el planificador de hilos considera que es el
momento), el método run() de la clase en que todo esto suceda.
Por ejemplo, el siguiente programa utiliza dos hilos, el hilo general main, y el hilo
thDemo que creamos.
import java.io.*;
import java.net.*;
class ThreadDemo implements Runnable {
ThreadDemo() {
Thread thDemo = new Thread( this, "ThDemo" );
thDemo.start();
};
public void run() {
try {
Thread.sleep(3000);
} catch( InterruptedException e ) { };
System.out.println("Saliendo del hilo hijo");
};
public static void main( String args[] ){
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 94 de 189
new ThreadDemo();
try {
for ( int i = 5 ; i >0 ; i-- ) {
System.out.println(" Seg: " + i );
Thread.sleep(1000);
}
} catch( InterruptedException e ) { };
System.out.println("Saliendo del main");
};
};
Ambos hilos esperan utilizando el método sleep() de la clase Threaa; thDemo tres
segundos, y main cinco segundos. Java utilizará los tres segundos de thDemo para ir
esperando los tres primeros segundos del hilo main.
Por lo tanto la salida por pantalla al ejecutar el programa es:
prompt> java ThreadDemo
Seg: 5
Seg: 4
Seg: 3
Saliendo del hilo hijo
Seg: 2
Seg: 1
Saliendo del hilo main
C. SINCRONIZACIÓN DE THREADS
Durante la ejecución de un programa, muchas veces varios procesos han de realizar
tareas de una forma sincronizada, actuando en un determinado orden. Para ello en Java
se utilizan la palabra reservada svncronizea, en la declaración de los procesos con este
tipo de características.
Los procesos declarados como svncronizea mediante la utilización de excepciones, y de
las funciones wait() y notifiv(), respectivamente esperarán a que otro proceso acabe
antes de continuar su ejecución.
A continuación se va a ir viendo cómo implementar el clásico problema de exclusión
mutua conocido como el problema ael proauctor/consumiaor, en el que dos procesos
han de acceder a una cola común, en la que el proceso proauctor inserta elementos en la
pila, y el proceso consumiaor ha de ir consumiendo los elementos en la pila, cada vez
que sean insertados:
class ColaSincronizada {
int n;
boolean bandera = false;
synchronized int obten() {
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 95 de 189
if ( !bandera )
try wait(); catch( InterruptedException e );
System.out.println( "Obtenido: " + n );
bandera = false;
notify();
return n;
}
synchronized void coloca( int paramN ) {
if ( bandera )
try wait(); catch( InterruptedException e );
n = paramN;
bandera =true;
System.out.println( "Colocado: " + n );
notify();
}
}

class Productor implements Runnable {
ColaSincronizada colaProductor;
Productor( ColaSincronizada paramCola ) {
colaProductor = paramCola;
new Thread( this, "Producer" ).start();
}
public void run() {
int i = 0;
while ( true ) // Bucle infinito
colaProductor.coloca( i++ );
}
}

class Consumidor implements Runnable {
ColaSincronizada colaConsumidor;
Consumidor( ColaSincronizada paramCola ) {
colaConsumidor = paramCola;
new Thread( this, "Consumidor" ).start();
}
public void run() {
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 96 de 189
while ( true ) // Bucle infinito
colaConsumidor.obten( );
}
}

public static void main( String args[] ) {
ColaSincronizada colaLocal = new ColaSincronizada();
new Productor( colaLocal );
new Consumidor( colaLocal );
}
La salida del programa será:
Colocado: 1
Obtenido: 1
Colocado: 2
Obtenido: 2
Colocado: 3
Obtenido: 3
. . .
D. Y MUCHO MÁS
La utilización de programación concurrente y de los hilos de Java con toda su potencia
va mucho más allá de los objetivos de este tutorial. Lo que aquí se ha visto es
simplemente una introducción para que el lector sea consciente de cuál es la potencia de
este tipo de programación.
La utilización de los threaas se extiende con métodos para que el programador controle
la alternancia de los hilos. Estos métodos son:
Œ suspena(), Bloquea temporalmente la ejecución de un hilo.
Πresume(), Activa un hilo bloqueado.
Œ stop(), Finaliza la ejecución de un hilo.
Para más información sobre los threaas véase }Zolli, 1997].
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 97 de 189
II.12 CREACIÓN DE PROGRAMAS JAVA
A. INTRODUCCIÓN
Una vez entendida la sintaxis y funcionalidad de Java, hay que explicar cómo combinar
todos los elementos introducidos para desarrollar programas Java.
La programación Java va mucho más allá de lo que la definición del lenguaje permite.
Son muchos los tipos de aplicaciones que se pueden crear con Java, así como su
utilización, especialmente gracias a la versatilidad de las bibliotecas de clases que
completan el Java básico.
B. TIPOS DE APLICACIONES
a.) Introducción
Con Java se pueden construir varios tipos de programas, cada uno con unas
características específicas, y que se ejecutan de distintas maneras.
A continuación se explican los principales tipos: Aplicaciones, Applets, JavaBeans,
JavaScript y Servlets.
Para más información véase }Morgan, 1999] y }Zolli, 1997].
b.) Aplicaciones
Son los programas básicos de Java. Se ejecutan en una determinada máquina, por el
Java Runtime Enviroment (JRE).
Para crear una aplicación hace falta incluir en alguna de las clases que compongan la
aplicación un método denominado:
Πpublic static voia main(String[{ s){ }
Hay que indicar al JRE (comando iava del JDK) el nombre de la clase (previamente
compilada a .class), que queremos ejecutar. Cuando se ejecute el programa lo que
realmente se ejecutará será el método main() de la clase indicada al JRE.
Las aplicaciones soportan métodos nativos, o sea, incluir en el programa código escrito
en otros lenguajes de programación, así como violar algunas de las directrices de
seguridad.
En cada fichero Java (.iava) sólo debe haber una clase pública.
c.) Applets
Las applets o miniaplicaciones Java, son programas que deben incluirse en páginas Web
para ser observadas por otra aplicación (visualizador de applets o navegador Web), y
que se ejecutan cuando el usuario intenta visualizarlas (cargando la página Web).
Las applets deben incluir un método de nombre start(), que será ejecutado cuando el
navegador intente mostrar por pantalla la applet.
Estas aplicaciones, son seguras (cumplen la especificación Java), y al ser distribuibles
por Internet no permiten incluir métodos nativos Java.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 98 de 189
d.) JavaBeans
Los JavaBeans son componentes gráficos de Java, que se pueden incorporar a otros
componentes gráficos. Se incluyen en la API de Java (paquete iava.beans).
Existe una herramienta de Sun, denominada BDK (Beans Developer Kit), que es un
conjunto de herramientas para desarrollar JavaBeans. El BDK, es el JDK para el
desarrollo de JavaBeans.
Existen ya multitud de bibliotecas con JavaBeans, para que puedan ser utilizados.
e.) JavaScript
JavaScript es un subconjunto del lenguaje Java que puede codificarse directamente
sobre cualquier documento HTML; el código fuente de JavaScript forma parte del
propio documento HTML.
JavaScript tiene menos potencia que Java, a cambio de más control sobre el navegador
Web que lo ejecute.
Se utiliza sobre todo para dar animación e interactividad a páginas Web.
JavaScript posee una habilidad limitada para interactuar con applets Java, pero Java no
puede interactuar de ningún modo con JavaScript.
f.) Servlets
Son módulos que permiten sustituir o utilizar el lenguaje Java en lugar de programas
CGI (Common Gateway Interface) a la hora de dotar de interactividad a las páginas
Web.
Estas aplicaciones se ejecutan como aplicaciones servidoras en Internet, y normalmente
incluyen bucles infinitos a la espera de peticiones a las que atender.
Los Servlets no tienen entorno gráfico, ya que se ejecutan en el servidor. Reciben datos
y su respuesta más habitual suele ser código HTML (páginas Web).
C. RECOMENDACIONES DE PROGRAMACIÓN
a.) Introducción
Es un hecho innegable que cada programador tiene su forma personal de programar, sus
preferencias de indentación...
En cualquier caso, desde este tutorial se proponen una serie de pautas que ayudarán a
que sus programas sean más legibles, mantenibles y eficientes:
b.) Propuestas de estilo de los fuentes
Utilice nombres significativos para los identificadores, y procure respetar la siguiente
notación de mayúsculas y minúsculas:
ΠLas clases: Clase o MiClase.
ΠLas interfaces: Interfaz o MiInterfaz.
Œ Los métodos: metoao() o metoaoLargo().
Œ Los métodos de acceso: getAtributo(). setAtributo().
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 99 de 189
ΠLas variables: altura o alturaMeaia.
ΠLas constantes: CONSTATE o CONSTANTELARGA.
ΠLos paquetes: iava.paquete.subpaquete.
Cuide los nombres de sus clases y paquetes para que no coincidan con otros ya
existentes, mediante la utilización de prefijos identificativos de usted o de su empresa.
Además se enuncian las siguientes recomendaciones:
Œ No utilice líneas de más de 80 caracteres, en su lugar divida la línea en varias.
Œ Escriba una única operación en cada línea.
Œ Inserte líneas en blanco en sus fuentes cuando mejoren la legibilidad.
ΠNo deje de incluir comentarios en sus clases, describiendo su funcionalidad. Si
utiliza la notación estandarizada /'' '/, además podrá recolectarles automáticamente
con iavaaoc.
c.) Propuestas de diseño de los programas
Para cada clase:
ΠCree un constructor por defecto.
ΠLos atributos de las clases no deben de ser public.
Œ Declare métodos de acceso a los atributos.
Œ Cree métodos de acceso a los atributos; getAtributo() y setAtributo(nuevoJalor). Si
no están implementados declárelos como private.
Œ Cree un método main() que valga para probar la clase.
Œ Sobre finalize(): Cree una bandera de finalización en cada clase, y en los finalize(),
si la bandera no ha sido establecida, lance una clase derivada de RuntimeException.
No olvide llamar a super.finalize().
Además se enuncian las siguientes recomendaciones:
ΠCree paquetes para agrupar clases relacionadas. Utilizar la herencia para simplificar
las clases con características comunes.
ΠUtilice interfaces antes que clases abstractas.
Œ Utilice composición cuando sea apropiado, no abuse de la herencia.
Para más información véase }1ohnson, 1996] y }Eckel, 1997].
D. GRANDES PROGRAMAS
Aunque con todo lo que se ha visto podríamos aventurarnos a desarrollar programas
Java un tanto complejos (con varias clases, paquetes, threaas...), lo cierto es que el
desarrollo de programas complejos es materia de la Ingeniería del Software.
Desde este tutorial se apuesta por la Ingeniería del Software para el desarrollo de
software de calidad, en un tiempo mínimo y con unos costes mínimos. La Ingeniería del
Software hace posible que un programa sea mantenible y eficiente, y resuelva un
problema de una forma adecuada.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 100 de 189
Desde aquí se recomienda el uso de una metodología orientada a objeto para el
desarrollo del software. Por ejemplo OMT de }Rambaugh et al., 1998], se ajusta
bastante bien al desarrollo de Java, además de ser la metodología más extendida
actualmente.
Todos los diagramas que se realicen siguiendo una metodología software deben de
realizarse utilizando una notación unificada. El lenguaje de modelado UML }Rational,
1997], se presenta como estándar de modelado.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 101 de 189
TEMA III: BIBLIOTECAS DE LA API DE JAVA
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 102 de 189
III.1. BIBLIOTECAS DE LA API DE JAVA
A. INTRODUCCIÓN
Con cada una de las versiones que Sun lanza del JDK, se acompaña de una serie de
bibliotecas con clases estándar que valen como referencia para todos los programadores
en Java.
Estas clases se pueden incluir en los programas Java, sin temor a fallos de portabilidad.
Además, están bien documentadas (mediante páginas Web), y organizadas en paquetes
y en un gran árbol de herencia.
A este conjunto de paquetes (o bibliotecas) se le conoce como la API de Java
(Application Programming Interface).
En este apartado explicaremos los paquetes básicos de la API de Java, aunque algunos
de ellos tienen subpaquetes.
B. PAQUETES DE UTILIDADES
Πiava.lang: Fundamental para el lenguaje. Incluye clases como String o StringBuffer,
que se tratan más en detenimiento en el capítulo "III.2 Caaenas" de este tutorial.
Œ iava.io: Para la entrada y salida a través de flujos de datos, y ficheros del sistema. Se
estudia en el capítulo "III.3 Entraaa/Saliaa" de este tutorial.
Πiava.util: Contiene colecciones de datos y clases, el modelo de eventos, facilidades
horarias, generación aleatoria de números, y otras clases de utilidad.
Œ iava.math: Clases para realizar aritmética con la precisión que se desee.
Œ iava.text: Clases e interfaces para manejo de texto, fechas, números y mensajes de
una manera independiente a los lenguajes naturales.
Œ iava.securitv: Clases e interfaces para seguridad en Java: Encriptación RSA...
C. PAQUETES PARA EL DESARROLLO GRÁFICO
Πiava.applet: Para crear applets y clases que las applets utilizan para comunicarse con
su contexto. Se estudia en el capítulo "JI. Applets" de este tutorial.
Œ iava.awt: Para crear interfaces con el usuario, y para dibujar imágenes y gráficos. Se
estudia en el capítulo "IJ. Bibliotecas graficas" de este tutorial.
Œ iavax.swing: Conjunto de componentes gráficos que funcionan igual en todas las
plataformas que Java soporta. Se estudia en el capítulo "IJ. Bibliotecas graficas" de
este tutorial.
Πiavax.accesibilitv: Da soporte a clases de accesibilidad para personas discapacitadas.
Πiava.beans: Para el desarrollo de JavaBeans.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 103 de 189
D. PAQUETES PARA EL DESARROLLO EN RED
Œ iava.net: Clases para aplicaciones de red. Se estudia en el capítulo "J. Java e
Internet" de este tutorial.
Œ iava.sql: Paquete que contiene el JDBC, para conexión de programas Java con
Bases de datos.
Πiava.rmi: Paquete RMI, para localizar objetos remotos, comunicarse con ellos e
incluso enviar objetos como parámetros de un objeto a otro.
Œ org.omg.CORBA: Facilita la posibilidad de utilizar OMG CORBA, para la conexión
entre objetos distribuidos, aunque esté codificados en distintos lenguajes.
Πorg.omb.CosNaming : Da servicio al IDL de Java, similar al RMI pero en CORBA
E. PARA MÁS INFORMACIÓN
Para más información consulte con la documentación del JDK que vaya a utilizar o la
dirección www.sun.com.
Esta información ha sido extraída de la documentación de la API de Java
correspondiente al JDK 1.2 }Sun, 1998].
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 104 de 189
III.2. CADENAS
A. INTRODUCCIÓN
a.) Introducción a las clases String y StringBuffer
En Java las cadenas se tratan de forma diferente a C/C++, donde las cadenas son
matrices de caracteres en las que se indica el final de la cadena con un carácter de valor
‘\0’.
En Java las cadenas son objetos de las clases predefinida String o StringBuffer, que
están incluidas en el paquete iava.lang.'.
Siempre que aparecen conjuntos de caracteres entre comillas dobles, el compilador de
Java crea automáticamente un objeto String.
Si sólo existieran cadenas de sólo lectura (String), durante una serie de manipulaciones
sobre un objeto String habría que crear un nuevo objeto para cada uno de los resultados
intermedios.
El compilador es más eficiente y usa un objeto StringBuffer para construir cadenas a
partir de las expresiones, creando el String final sólo cuando es necesario. Los objetos
StringBuffer se pueden modificar, de forma que no son necesarios nuevos objetos para
albergar los resultados intermedios.
Los caracteres de las cadenas tienen un índice que indica su posición. El primer carácter
de una cadena tiene el índice 0, el segundo el 1, el tercero el 2 y así sucesivamente. Esto
puede sonar familiar a los programadores de C/C++, pero resultar chocante para
aquellos programadores que provengan de otros lenguajes.
b.) Operaciones básicas, comunes a String y StringBuffer
Existen una serie de métodos que son comunes a ambas clases.
Los siguientes métodos de acceso a las cadenas:
Œ int length(); Devuelve el número de caracteres de la cadena.
Œ char charAt( int i ), Devuelve el carácter correspondiente de índice i.
Los siguientes métodos para crear cadenas derivadas:
ΠString toString(), Devuelve una copia del objeto como una String.
ΠString substring( int i. int fin ), Devuelve una instancia de la clase String que
contenga una subcadena desde la posición ini, hasta la fin (si no se indica hasta el
final de la cadena), del objeto cadena que invoque el método.
Y el método para transformar la cadena en un vector de caracteres:
Πvoia getChars(int ini. int fin. char[{ aestino. int aestIni), Convierte la cadena en un
vector de caracteres aestino.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 105 de 189
B. MÉTODOS DE LA CLASE STRING
a.) Constructores
La clase String proporciona cadenas de sólo lectura y soporta operaciones con ellas. Se
pueden crear cadenas implícitamente mediante una cadena entrecomillada o usando ¹ ó
¹ con dos objetos String.
También se pueden crear objetos String explícitamente con el mecanismo new.
La clase String soporta multitud de constructores.
ΠString(), Constructor por defecto. El nuevo String toma el valor "".
Œ String( String s ), Crea un nuevo String, copiando el que recibe por parámetro.
ΠString( StringBuffer s ), Crea un String con el valor que en ese momento tenga el
StringBuffer que recibe como parámetro.
ΠString( char[{ v ), El nuevo String toma el valor de los caracteres que tiene el vector
de caracteres recibido por parámetro.
ΠString( bvte[{ v ), El nuevo String toma el valor de los caracteres que corresponden
a los valores del vector de bytes en el sistema de caracteres de la ordenador en que
se ejecute.
b.) Búsqueda en cadenas String
Además presenta los siguientes métodos para buscar caracteres o subcadenas en la
cadena, y devuelven el índice que han encontrado o el valor 1 si la búsqueda no ha sido
satisfactoria:
Œ int inaexOf( char ch. int start ): Devuelve el índice correspondiente a la primera
aparición del carácter ch en la cadena, comenzando a buscar desde el carácter start
(si no se especifica se busca desde el principio).
Œ int inaexOf( String str ): Devuelve el índice correspondiente al carácter en que
empieza la primera aparición de la subcadena str.
Œ int lastInaexOf( char ch. int start ): Devuelve el índice correspondiente a la última
aparición del carácter ch en la cadena, comenzando a buscar desde el carácter start
(si no se especifica se busca desde el final).
Œ int lastInaexOf( String str ): Devuelve el índice correspondiente al carácter en que
empieza la última aparición de la subcadena str.
c.) Comparaciones de cadenas String
Java no trabaja con el código ASCII habitual, sino con el código avanzado Unicoae.
El código Unicoae (código universal) se caracteriza, sobre todo, por el uso de dos bytes
por carácter. Esto permite aumentar los caracteres hasta 65000, y así se pueden
representar los caracteres que componen las lenguas, vivas o muertas, más importantes
del mundo.
Hay que tener en cuenta que si nos salimos del rango 0-255 que coincide con el código
ASCII puede que las comparaciones no sean las esperadas.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 106 de 189
Las funciones de comparación son las siguientes:
Πboolean equals( Obiect o ), Devuelve true si se le pasa una referencia a un objeto
String con los mismos caracteres, o false si no.
Πboolean equalsIgnoreCase( String s ), Compara cadenas ignorando las diferencias
de ortografía mayúsculas/minúsculas.
Πboolean regionMatches( boolean b. int o. String s . int i. int n ), Compara parte de
dos cadenas, carácter a carácter.
Πboolean startsWith( String s. int i ); Comprueba si la cadena tiene el prefijo s desde
i.
Πboolean enasWith( String s ), Comprueba si la cadena termina con el sufijo s.
Πint compareTo( Obiect o ), Devuelve un entero que es menor, igual o mayor que
cero cuando la cadena sobre la que se le invoca es menor, igual o mayor que la otra.
Si el parámetro es un String, la comparación es léxica.
Œ int compareToIgnoraCase( String s ), Compara lexicográficamente, ignorando las
diferencias de ortografía mayúsculas/minúsculas.
d.) Cadenas String derivadas
En Java se devuelven nuevas cadenas cada vez que se invoca a un método que crea una
cadena diferente porque las cadenas String son de sólo lectura:
ΠString replace( char olaChar. char newChar ), Devuelve una nueva cadena con
todos los caracteres olaChar sustituidos por el carácter newChar.
ΠString toLowerCase(), Devuelve una nueva cadena con los caracteres en
minúsculas, o si se especifica parámetro, siguiendo sus reglas.
ΠString toUperCase( Locale l ), Devuelve una nueva cadena con los caracteres en
mayúsculas, o si se especifica parámetro, siguiendo sus reglas.
Πstatic String trim(): Devuelve una nueva cadena del que se ha eliminado los espacios
en blanco por el principio y por el final.
Πstatic String copvJalueOf( char[{ v. int ini. int fin ), Devuelve una cadena igual que
la contenida en el vector v, entre los límites ini y fin (si no se especifican copia todo
el vector).
Œ static String concat( String s ); Concatena la cadena que recibe al final de ésta.
e.) Conversiones entre cadenas String y tipos simples Java
Para convertir una variable de un tipo de datos simple (char, boolean. int. long. float.
aouble) en una cadena (String), bastará con invocar al método valueOf() del objeto
String correspondiente:
Œ static String valueOf( tipo ), El parámetro tipo soporta un carácter (char) un vector
de caracteres (char[{) o un objeto (Obiect).
Sin embargo para convertir el valor de una cadena en un tipo de datos simple deberemos
utilizar los siguientes métodos:
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 107 de 189

1ipo De String
boolean new Boolean(String).booleanJalue()
int Integer.ParseInt(String. int base)
long Long.ParseLong(String. int base)
float new Float(String).floatJalue()
aouble new Double(String).aoubleJalue()
Tabla 20. Conversiones ae caaenas a tipos simples
No hay ningún método que convierta los caracteres escapados Java ( \b, \uaaaa ) en
variables carácter (char). o a la inversa. Lo que se puede hacer es invocar valueOf() con
un carácter (char) para obtener una cadena de la clase String que contenga ese carácter.
Así mismo no hay formas de crear o decodificar cadenas de números en formatos octal
(0) o hexadecimal(0x).
f.) Conversiones entre cadenas String y vectores
También existen diversos constructores y métodos de la clase String para tratar con
vectores, tanto de caracteres como de bytes.
En cuanto a los vectores de caracteres existen:
ΠEl constructor ya citado de String( char[{ v ). Hace copia de los datos, por lo que las
modificaciones posteriores del vector no afectarán a la cadena.
Πchar[{ toCharArrav(), Convierte la cadena en un vector de caracteres.
En cuanto a los métodos para convertir vectores de bvte (de 8 bits) en objetos String con
caracteres Unicoae de 16 bits existen:
ΠEl constructor ya citado de String( bvte[{ v ). Hace copias de los datos, por lo que
las modificaciones posteriores del vector no afectarán a la cadena.
Πbvte[{ getBvtes( String s ), Convierte la cadena en un vector de bvte, atendiendo a la
tabla de caracteres especificada en s, o a la de la máquina si se omite.
C. MÉTODOS DE LA CLASE STRINGBUFFER
a.) Constructores
Los constructores contenidos por la clase StringBuffer son:
ΠStringBuffer( int lim ), Construye una cadena sin caracteres y con una capacidad
inicial de lim caracteres (por defecto 16, si no se especifica otro valor).
ΠStringBuffer( String s ), Construye una cadena con el valor s.
b.) Modificación de la cadena
Existen tres tipos de modificaciones que se pueden aplicar a la cadena.
Hay métodos de inserción:
ΠStringBuffer insert( int i. Obiect o ), Desplaza los caracteres de la cadena e inserta la
cadena correspondiente al segundo parámetro (de cualquier tipo).
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 108 de 189
ΠStringBuffer appena( Obiect o ), Inserta al final de la cadena, la cadena
correspondiente al segundo parámetro (de cualquier tipo).
Hay métodos de substitución:
Œ voia setCharAt( int i. char to ), Cambia el carácter de la posición i por to. Si la
posición supera la longitud de la cadena, se extiende rellenándose con caracteres
nulos.
ΠStringBuffer replace( int ini. int fin. String s ), Reemplaza una subcadena de esta
cadena (de ini a fin) por la cadena recibida por parámetro. No se debe confundir con
el método replace() que incluye la clase String.
ΠStringBuffer reverse(); Invierte la cadena (de izquierda a derecha).
Y métodos de borrado:
Œ StringBuffer aelete( int ini. int fin ), Borra la subcadena entre el carácter ini y el fin.
Œ StringBuffer aeleteCharAt( int i ), Borra el carácter en la posición i.
c.) Capacidad de la cadena
El buffer de un objeto StringBuffer tiene una capaciaaa que es la longitud de la cadena
que puede almacenar sin tener que asignar más espacio. El buffer crece
automáticamente a medida que se añaden caracteres, pero resulta más eficiente
especificar el tamaño del buffer de una sola vez:
Πint capacitv(), Devuelve la capacidad actual del buffer.
Πvoia ensureCapacitv( int i ),. Garantiza que la capacidad del buffer es al menos i.
Πvoia setLength( int i ), Establece la longitud de esta cadena a i.
d.) Extracción de datos
Para obtener un objeto String a partir de un objeto StringBuffer, debe invocarse el
método toString(), común a ambas clases.
Se debe tener en cuenta que no hay métodos StringBuffer para eliminar una parte de un
buffer. Para resolver este problema, debe crearse un vector de caracteres a partir del
buffer, y construir un nuevo buffer con el contenido restante. Para esto se usa el método
getChars(), común con la clase String.
D. EJEMPLOS DE USO DE CADENAS
a.) Ejemplo de Cadena Fija (de la clase String)
En el siguiente ejemplo se muestra la utilización de los principales métodos de la clase
String:
public static void main( String s[] ){
String cad = new String("Cadena Fija");
System.out.println("Ejemplo de String: ’"+cad+"’");
//Métodos comunes a StringBuffer
System.out.println("Su longitud es: "+cad.length());
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 109 de 189
System.out.println("Su tercer caracter es: "+cad.charAt(3));
System.out.print("Su subcadena del 3 al 6 es:");
System.out.println( cad.substring(2,6) );
char[] vectorcad = cad.toCharArray();
System.out.println("Creado un vector, de elemento 3: ");
System.out.print( vectorcad[2] );
// Búsqueda en cadenas
String subcad=new String("ena");
System.out.print("La subcadena '"+subcad+"'");
System.out.print(" aparece en la posicion: ");
System.out.println( cad.indexOf(subcad) );
// Comparaciones
String cadcomp=new String("CADENA Fija");
System.out.print("La cadena '"+cadcomp+"'");
if ( cad.compareTo(cadcomp) == 0 )
System.out.println(" ES igual 'Sensitive'");
else
System.out.println(" NO es igual 'Sensitive'");
System.out.print("La cadena '"+cadcomp+"'");
if ( cad.equalsIgnoreCase(cadcomp) )
System.out.println(" ES igual 'Insensitive'");
else
System.out.println(" NO = 'Insensitive'");
// Derivación
System.out.print("Cadena derivada en minusculas: ");
System.out.println( cad.toLowerCase() );
}
Lo que muestra por pantalla:
Ejemplo de String: 'Cadena Fija'
Su longitud es: 11
Su tercer caracter es: e
Su subcadena del 3 al 6 es: dena
Creado un vector, de elemento 3: d
La subcadena 'ena' aparece en la posicion: 3
La cadena 'CADENA Fija' NO es igual 'Sensitive'
La cadena 'CADENA Fija' ES igual 'Insensitive'
Cadena derivada en minusculas: cadena fija
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 110 de 189
b.) Ejemplo de Cadena Variable (de la clase StringBuffer)
En el siguiente ejemplo se muestra la utilización de los principales métodos de la clase
StringBuffer:
public static void main( String s[] ){
StringBuffer cad = new StringBuffer("Cadena Variable");
System.out.println("Ejemplo de StringBuffer: ’"+cad+"’");
// Modificación de la cadena
cad.delete( 0, 6 );
System.out.println("Borrados 6 primeros caracteres: "+cad);
cad.replace( cad.length()-3, cad.length(), "da" );
System.out.println("Sutituidos ultimos caracteres: "+cad);
cad.append(" Cadena");
System.out.println("Apendizada con 'Cadena': "+cad);
// Gestión de su capacidad
System.out.println("Tiene capacidad de: "+cad.capacity());
cad.ensureCapacity( 32 );
System.out.println("Capacidad sobre 32:"+cad.capacity());
System.out.println("");
}
Lo que muestra por pantalla:
Ejemplo de StringBuffer: 'Cadena Variable'
Borrados 6 primeros caracteres: Variable
Sutituidos ultimos caracteres: Variada
Apendizada con 'Cadena': Variada Cadena
Tiene capacidad de: 31
Capacidad sobre 32: 64
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 111 de 189
III.3. ENTRADA/SALIDA
A. INTRODUCCIÓN
Normalmente, cuando se codifica un programa, se hace con la intención de que ese
programa pueda interactuar con los usuarios del mismo, es decir, que el usuario pueda
pedirle que realice cosas y pueda suministrarle datos con los que se quiere que haga
algo. Una vez introducidos los datos y las órdenes, se espera que el programa manipule
de alguna forma esos datos para proporcionarnos una respuesta a lo solicitado.
Además, en muchas ocasiones interesa que el programa guarde los datos que se le han
introducido, de forma que si el programa termina los datos no se pierdan y puedan ser
recuperados en una sesión posterior. La forma más normal de hacer esto es mediante la
utilización de ficheros que se guardarán en un dispositivo de memoria no volátil
(normalmente un disco).
A todas estas operaciones, que constituyen un flujo de información del programa con el
exterior, se les conoce como Entraaa/Saliaa (E/S).
Existen dos tipos de E/S; la E/S estanaar que se realiza con el terminal del usuario y la
E/S a traves ae fichero, en la que se trabaja con ficheros de disco.
Todas las operaciones de E/S en Java vienen proporcionadas por el paquete estándar de
la API de Java denominado iava.io que incorpora interfaces, clases y excepciones para
acceder a todo tipo de ficheros. En este tutorial sólo se van a dar algunas pinceladas de
la potencia de este paquete.
B. ENTRADA/SALIDA ESTÁNDAR
Aquí sólo trataremos la entrada/salida que se comunica con el usuario a través de la
pantalla o de la ventana del terminal.
Si creamos una applet no se utilizarán normalmente estas funciones, ya que su resultado
se mostrará en la ventana del terminal y no en la ventana de la applet. La ventana de la
applet es una ventana gráfica y para poder realizar una entrada o salida a través de ella
será necesario utilizar el AWT.
El acceso a la entrada y salida estándar es controlado por tres objetos que se crean
automáticamente al iniciar la aplicación: Svstem.in, Svstem.out y Svstem.err
a.) System.in
Este objeto implementa la entrada estándar (normalmente el teclado). Los métodos que
nos proporciona para controlar la entrada son:
Œ reaa(). Devuelve el carácter que se ha introducido por el teclado leyéndolo del
buffer de entrada y lo elimina del buffer para que en la siguiente lectura sea leído el
siguiente carácter. Si no se ha introducido ningún carácter por el teclado devuelve el
valor -1.
Πskip(n). Ignora los n caracteres siguientes de la entrada.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 112 de 189
b.) System.out
Este objeto implementa la salida estándar. Los métodos que nos proporciona para
controlar la salida son:
Œ print(a). Imprime a en la salida, donde a puede ser cualquier tipo básico Java ya que
Java hace su conversión automática a cadena.
Œ println(a). Es idéntico a print(a) salvo que con println() se imprime un salto de línea
al final de la impresión de a.
c.) System.err
Este objeto implementa la salida en caso de error. Normalmente esta salida es la
pantalla o la ventana del terminal como con Svstem.out, pero puede ser interesante
redirigirlo, por ejemplo hacia un fichero, para diferenciar claramente ambos tipos de
salidas.
Las funciones que ofrece este objeto son idénticas a las proporcionadas por Svstem.out.
d. Ejemplo
A continuación vemos un ejemplo del uso de estas funciones que acepta texto hasta que
se pulsa el retorno de carro e informa del número de caracteres introducidos.
import java.io.*;
class CuentaCaracteres {
public static void main(String args[]) throws IOException {
int contador=0;
while(System.in.read()!=’\n’)
contador++;
System.out.println(); // Retorno de carro "gratuito"
System.out.println("Tecleados "+contador+" caracteres.");
}
}
C. ENTRADA/SALIDA POR FICHERO
a.) Tipos de ficheros
En Java es posible utilizar dos tipos de ficheros (de texto o binarios) y dos tipos de
acceso a los ficheros (secuencial o aleatorio).
Los ficheros de texto están compuestos de caracteres legibles, mientras que los binarios
pueden almacenar cualquier tipo de datos (int, float, boolean....).
Una lectura secuencial implica tener que acceder a un elemento antes de acceder al
siguiente, es decir, de una manera lineal (sin saltos). Sin embargo los ficheros de acceso
aleatorio permiten acceder a sus datos de una forma aleatoria, esto es indicando una
determinada posición desde la que leer/escribir.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 113 de 189
b.) Clases a estudiar
En el paquete iava.io existen varias clases de las cuales podemos crear instancias de
clases para tratar todo tipo de ficheros.
En este tutorial sólo vamos a trata las tres principales:
ΠFileOutputStream: Fichero de salida de texto. Representa ficheros de texto para
escritura a los que se accede de forma secuencial.
Œ FileInputStream: Fichero de entrada de texto. Representa ficheros de texto de sólo
lectura a los que se accede de forma secuencial.
ΠRanaomAccessFile: Fichero de entrada o salida binario con acceso aleatorio. Es la
base para crear los objetos de tipo fichero de acceso aleatorio. Estos ficheros
permiten multitud de operaciones; saltar hacia delante y hacia atrás para leer la
información que necesitemos en cada momento, e incluso leer o escribir partes del
fichero sin necesidad de cerrarlo y volverlo a abrir en un modo distinto.
c.) Generalidades
Para tratar con un fichero siempre hay que actuar de la misma manera:
1. Se abre el fichero.
Para ello hay que crear un objeto de la clase correspondiente al tipo de fichero que
vamos a manejar, y el tipo de acceso que vamos a utilizar:
TipoDeFichero obj = new TipoDeFichero( ruta );
Donde ruta es la ruta de disco en que se encuentra el fichero o un descriptor de fichero
válido.
Este formato es válido, excepto para los objetos de la clase RanaomAccessFile (acceso
aleatorio), para los que se ha de instanciar de la siguiente forma:
RandomAccessFile obj = new RandomAccessFile( ruta, modo );
Donde moao es una cadena de texto que indica el modo en que se desea abrir el fichero;
"r" para sólo lectura o "rw" para lectura y escritura.
2. Se utiliza el fichero.
Para ello cada clase presenta diferentes métodos de acceso para escribir o leer en el
fichero.
3. Gestión de excepciones (opcional, pero recomendada)
Se puede observar que todos los métodos que utilicen clases de este paquete deben tener
en su definición una cláusula throws IOException. Los métodos de estas clases pueden
lanzar excepciones de esta clase (o sus hijas) en el transcurso de su ejecución, y dichas
excepciones deben de ser capturadas y debidamente gestionadas para evitar problemas.
4. Se cierra el fichero y se destruye el objeto.
Para cerrar un fichero lo que hay que hacer es destruir el objeto. Esto se puede realizar
de dos formas, dejando que sea el recolector de basura de Java el que lo destruya
cuando no lo necesite (no se recomienda) o destruyendo el objeto explícitamente
mediante el uso del procedimiento close() del objeto:
obj.close()
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 114 de 189
d.) La clase FileOutputStream
Mediante los objetos de esta clase escribimos en ficheros de texto de forma secuencial.
Presenta el método write() para la escritura en el fichero. Presenta varios formatos:
Œ int write( int c ). Escribe el carácter en el fichero.
Πint write( bvte a[{ ). Escribe el contenido del vector en el fichero.
Πint write( bvte a[{. int off. int len ). Escribe len caracteres del vector a en el fichero,
comenzando desde la posición off.
El siguiente ejemplo crea el fichero de texto "/carta.txt" a partir de un texto que se le
introduce por teclado:
import java.io.*;
class CreaCarta {
public static void main(String args[]) throws IOException{
int c;
FileOutputStream f=new FileOutputStream("/carta.txt");
while( ( c=System.in.read() ) != -1 )
f.write( (char)c );
f.close();
}
}
e.) La clase FileInputStream
Mediante los objetos de esta clase leemos de ficheros de texto de forma secuencial.
Presenta el método reaa() para la lectura del fichero. Este método se puede invocar de
varias formas.
Œ int reaa(). Devuelve el siguiente carácter del fichero.
Œ int reaa( bvte a[{ ). Llena el vector a con los caracteres leídos del fichero. Devuelve
la longitud del vector que se ha llenado si se realizó con éxito o –1 si no había
suficientes caracteres en el fichero para llenar el vector.
Œ int reaa( bvte a[{. int off. int len ). Lee len caracteres del fichero, insertándolos en el
vector a.
Todos ellos devuelven -1 si se ha llegado al final del fichero (momento de cerrarle).
El siguiente ejemplo muestra el fichero de texto "/carta.txt" en pantalla:
import java.io.*;
class MuestraCarta {
public static void main(String args[]) throws IOException {
int c;
FileInputStream f=new FileInputStream("/carta.txt");
while( ( c=f.read() ) != -1 )
System.out.print( (char)c );
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 115 de 189
f.close();
}
}
f.) La clase RandomAccessFile
Mediante los objetos de esta clase utilizamos ficheros binarios mediante un acceso
aleatorio, tanto para lectura como para escritura. En estos ficheros hay un índice que nos
dice en qué posición del fichero nos encontramos, y con el que se puede trabajar para
posicionarse en el fichero.
Métodos de desplazamiento
Cuenta con una serie de funciones para realizar el desplazamiento del puntero del
fichero. Hay que tener en cuenta que cualquier lectura o escritura de datos se realizará a
partir de la posición actual del puntero del fichero.
Œ long getFilePointer(),Devuelve la posición actual del puntero del fichero.
Œ voia seek( long l ), Coloca el puntero del fichero en la posición indicada por l. Un
fichero siempre empieza en la posición 0.
Œ int skipBvtes( int n ), Intenta saltar n bytes desde la posición actual.
Πlong length(), Devuelve la longitud del fichero.
Œ voia setLength( long l), Establece a l el tamaño de este fichero.
ΠFileDescriptor getFD(), Devuelve el descriptor de este fichero.
Métodos de escritura
La escritura del fichero se realiza con una función que depende el tipo de datos que se
desee escribir.
Πvoia write( bvte b[{. int ini. int len ), Escribe len caracteres del vector b.
Πvoia write( int i ), Escribe la parte baja de i (un byte) en el flujo.
Πvoia writeBoolean( boolean b ), Escribe el boolean b como un byte.
Πvoia writeBvte( int i ), Escribe i como un byte.
Πvoia writeBvtes( String s ), Escribe la cadena s tratada como bytes, no caracteres.
Πvoia writeChar( int i ), Escribe i como 1 byte.
Πvoia writeChars( String s ), Escribe la cadena s.
Πvoia writeDouble( aouble a ); Convierte a a long y le escribe como 8 bytes.
Πvoia writeFloat( float f ), Convierte f a entero y le escribe como 4 bytes.
Πvoia writeInt( int i ); Escribe i como 4 bytes.
Πvoia writeLong( long v ), Escribe v como 8 bytes.
Πvoia writeShort( int i ), Escribe i como 2 bytes.
Œ voia writeUTF( String s ), Escribe la cadena s utilizando la codificación UTF-8.
Los métodos que escriben números de más de un byte escriben el primero su parte alta.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 116 de 189
Métodos de lectura
La lectura del fichero se realiza con una función que depende del tipo de datos que
queremos leer.
Πboolean reaaBoolean(), Lee un byte y devuelve false si vale 0 o true sino.
Πbvte reaaBvte(), Lee y devuelve un byte.
Πchar reaaChar(), Lee y devuelve un caracter.
Πaouble reaaDouble(), Lee 8 bytes, y devuelve un aouble.
Πfloat reaaFloat(), Lee 4 bytes, y devuelve un float.
Πvoia reaaFullv( bvte b[{ ), Lee bytes del fichero y los almacena en un vector b.
Πvoia reaaFullv( bvte b[{. int ini. int len ), Lee len bytes del fichero y los almacena
en un vector b.
Πint reaaInt(), Lee 4 bytes, y devuelve un int.
Πlong reaaLong(), Lee 8 bytes, y devuelve un long.
Πshort reaaShort(), Lee 2 bytes, y devuelve un short.
Πint reaaUnsigneaBvte(), Lee 1 byte, y devuelve un valor de 0 a 255.
Πint reaaUnsigneaShort(), Lee 2 bytes, y devuelve un valor de 0 a 65535.
ΠString reaaUTF(), Lee una cadena codificada con el formato UTF-8.
Πint skipBvtes(int n), Salta n bytes del fichero.
Si no es posible la lectura devuelven 1.
Ejemplo
Vamos a crear un pequeño programa que cree y acceda a un fichero binario, mediante
acceso aleatorio.
El siguiente ejemplo crear un fichero binario que contiene los 100 primeros números (en
orden):
// Crea un fichero binario con los 100 primeros numeros
static void creaFichBin( String ruta ) throws IOException {
RandomAccessFile f=new RandomAccessFile(ruta,"rw"); // E/S
for ( int i=1; i <= 100 ; i++ )
{
try{
f.writeByte( i );
} catch( IOException e){
// Gestion de excepcion de ejemplo
break; // No se puede seguir escribiendo
}
f.close();
}
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 117 de 189
El siguiente método accede al elemento cual de un fichero binario, imprimiendo la
longitud del fichero, el elemento cual y su 10 veces siguiente elemento:
static void imprimeEltoN(String ruta, long cual)
throws IOException{

RandomAccessFile f=new RandomAccessFile(ruta,"r"); // E/

System.out.print( "El fichero " + ruta );
System.out.println( " ocupa " + f.length() + " bytes." );

f.seek( cual-1 ); // Me posiciono (-1 porque empieza en 0)
System.out.print(" En la posicion " + f.getFilePointer() );
System.out.println(" esta el numero " + f.readByte() );

f.skipBytes( 9 ); // Salto 9 => Elemento 10 mas alla
System.out.print(" 10 elementos más allá, esta el ");
System.out.println( f.readByte() );

f.close();
}

Si incluimos ambos métodos en una clase, y les llamamos con el siguiente programa
principal (main()):
public static void main(String args[]) throws IOException {
String ruta="numeros.dat"; // Fichero
creaFichBin( ruta ); // Se crea
imprimeEltoN( ruta, 14 ); // Accedo al elemento 14.
}
Obtendremos la siguiente salida:
El fichero numeros.dat ocupa 100 bytes.
En la posicion 13 esta el numero 14
10 elementos más allá, esta el 24
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 118 de 189
TEMA IV. BILIOTECAS GRÁFICAS
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 119 de 189
IV.1. LOS PAQUETES GRÁFICOS DE LAS JFC
A. INTRODUCCIÓN
Las JFC (Java Foundation Classes) son parte de la API de Java compuesto por clases
que sirven para crear interfaces gráficas visuales para las aplicaciones y applets de Java.
Así como Sun presenta estas JFC, Microsoft ha desarrollado otro paquete propio con el
nombre de AFD (Application Foundation Classes).
Las JFC contienen dos paquetes gráficos: AWT y Swing.
Œ AWT presenta componentes pesados, que en cada plataforma sólo pueden tener una
representación determinada. Está disponible desde la versión 1.1 del JDK como
iava.awt.
ΠSwing presenta componentes ligeros, que pueden tomar diferente aspecto y
comportamiento pues lo toman de una biblioteca de clases. Está disponible desde la
versión 1.2 del JDK como iavax.swing aunque antes se podían encontrar versiones
previas como com.sun.iava. o como iava.awt.swing.
AWT se estudia con más detenimiento en el apartado "IJ.2.AWT" de este tutorial,
mientras que Swing se estudia en el apartado "IJ.3.Swing" de este tutorial.
B. MODELO DE EVENTOS
Tanto AWT como Swing tienen en común un sistema para gestionar los eventos que se
producen al interactuar con el usuario de la interfaz gráfica; su moaelo ae eventos.
El funcionamiento del modelo de eventos se basa en la gestión de excepciones.
Para cada objeto que represente una interfaz gráfica, se pueden definir objetos "oyentes"
(Listener), que esperen a que suceda un determinado evento sobre la interfaz. Por
ejemplo se puede crear un objeto oyente que esté a la espera de que el usuario pulse
sobre un botón de la interfaz, y si esto sucede, él es avisado, ejecutando determinada
acción.
La clase base para todos estos eventos que se pueden lanzar es la clase AWTEvent
(perteneciente al paquete iava.awt).
El modelo de eventos de AWT depende del paquete iava.awt.event, que en Swing se
amplía con el paquete iavax.swing.event.
Existen dos tipos básicos de eventos:
Œ Físicos: Corresponden a un evento hardware claramente identificable. Ej: se ha
pulsado una tecla (KevStrokeEvent).
Œ Semánticos: Se componen de un conjunto de eventos físicos, que sucedidos en un
determinado orden tienen un significado más abstracto: El usuario ha elegido un
elemento de una lista desplegable (ItemEvent).
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 120 de 189
C. SUBPAQUETES DE AWT
A continuación se enumeran los paquetes que componen las JFC, así como su
funcionalidad, ordenados por orden de antigüedad. Esto es importante, porque debe de
tenerse en cuenta si se va a utilizar para crear applets, ya que normalmente los
navegadores no soportan la última versión de la API de Java en su propia máquina
virtual.
Si queremos que nuestra applet se vea igual en varios navegadores, deberemos de tener
en cuenta qué paquetes podemos utilizar y cuáles no, comprobando la versión de Java
que soportan los navegadores que nos interesen.
a.) Desde la versión 1.0
Œ iava.awt: Contiene todas las clases básicas de AWT para crear interfaces e imprimir
gráficos e imágenes, así como la clase base para los eventos en componentes:
AWTEvent.
Œ iava.awt.image: Para crear y modificar imágenes. Utiliza productores de imágenes,
filtros y "consumidores de imágenes". Permite renderizar una imagen mientras está
siendo generada.
b.) Desde la versión 1.1
Πiava.awt.aatatransfer: Transferencia de datos entre aplicaciones. Permite definir
clases "transferibles" entre aplicaciones, y da soporte al mecanismo del portapapeles
(copiar y pegar).
Πiava.awt.event: Modelo de eventos de AWT. Contiene eventos, oyentes y
adaptadores a oyentes.
c.) Desde la versión 1.2
Œ iava.awt.color: Utilización de colores. Contiene la implementación de una paleta de
colores basada en la especificada por el ICC (Consorcio Internacional de Color).
Πiava.awt.ana: Operaciones de arrastrar y soltar.
Πiava.awt.font: Todo lo referente a las fuentes de texto. Soporta fuentes del tipo True
Type, Type 1, Type 1 Multiple Master, y OpenType.
Πiava.awt.geom. Aporta clases de Java 2D, para crear objetos en 2 dimensiones,
utilizando geometría plana (elipses, curvas, áreas...).
Œ iava.awt.im: Para utilizar símbolos Japoneses, Chinos o Coreanos.
Œ iava.awt.image.renaerable: Para producir imágenes que sean inaepenaientes ae
reaering (animación).
Πiava.awt.print: Para imprimir documentos. Incorpora capacidad para gestionar
diversos tipos de documentos, formatos de página e interactuar con el usuario para
controlar la impresión de trabajos.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 121 de 189
D. SUBPAQUETES DE SWING
A continuación se enumeran los paquetes que componen Swing, así como su
funcionalidad:
Œ iavax.swing: Tiene los componentes básicos para crear componentes ligeros Swing.
Πiavax.swing.boraer: Para dibujar bordes personalizados en los componentes Swing.
Πiavax.swing.colorchooser: Para utilizar el componente JColorChooser.
Œ iavax.swing.event: Eventos lanzados por componentes Swing, así como oyentes para
dichos eventos. Extiende los que se encuentran en el paquete AWT iava.awt.event.
Πiavax.swing.filechooser: Para utilizar el componente JFileChooser.
Œ iavax.swing.plaf: Permite a Swing utilizar múltiples representaciones. Se utiliza por
aquellos desarrolladores que no pueden crear un nuevo aspecto de interfaz, basado
en los que Swing ya incorpora (como Basic o Metal).
Πiavax.swing.plaf.basic: Objetos que utilizan interfaces de aspecto "Basic". Este
aspecto es el que presentan por defecto los componentes Swing. En este paquete se
encuentran gestores de impresión, eventos, oyentes y adaptadores. Se puede crear un
aspecto personalizado de interfaz utilizando este paquete.
Πiavax.swing.plaf.metal: Objetos que utilizan interfaces de aspecto "Metal".
Πiavax.swing.plaf.multi: Permite a los usuarios combinar aspectos de interfaz, entre
auxiliares y los que existen por defecto.
Πiavax.swing.text: Para manejar componentes de texto (modificables o no). Soporta
sintaxis resaltada, edición, estilos...
Œ iavax.swing.text.html: Contiene la clase HTMLEaitorKit, basada en la versión 3.2 de
la especificación HTML, y clases para crear editores de texto HTML
Πiavax.swing.text.html.parser: Contiene analizadores de texto HTML.
Πiavax.swing.text.rtf: Contiene la clase RTFEaitorKit para crear editores de
documentos en formato RTF (Rich-Text-Format).
Œ iavax.swing.tree: Para personalizar la forma en que son utilizados los árboles
generados por la clase iava.awt.swing.JTree.
Πiavax.swing.unao: Permite realizar operaciones de aeshacer/rehacer en las
aplicaciones que cree el usuario.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 122 de 189
IV.2. AWT (Abstract Windowing Toolkit)
A. INTRODUCCIÓN
AWT es un conjunto de herramientas GUI (Interfaz Gráfica con el Usuario) diseñadas
para trabajar con múltiples plataformas.
Este paquete viene incluido en la API de Java como iava.awt ya desde su primera
versión, con lo que las interfaces generadas con esta biblioteca funcionan en todos los
entornos Java disponibles (incluyendo navegadores, lo que les hace especialmente
eficientes para la creación de applets Java).
En el apartado "JI.3. Eiemplo ae creacion ae una applet" se muestra un breve ejemplo
de cómo utilizar las clases del AWT para crear una applet y una aplicación de Java.
La siguiente figura muestra la jerarquía de clases para las principales clases de AWT:
Imagen 7. Jerarquia ae las clases ae AWT
En este apartado vamos a estudiar algunas de las clases más importantes del AWT, así
como su funcionalidad.
B. COMPONENT
Esta clase representa a cualquier objeto que puede ser parte de una interfaz gráfica de
usuario. Es la clase padre de muchas de las clases del AWT.
Su propósito principal es representar algo que tiene una posición y un tamaño, que
puede ser dibujado en la pantalla y que pueda recibir eventos de entrada (que responda a
las interacciones con el usuario).
La clase Component presenta diversos métodos, organizados para cubrir varios
propósitos.
A continuación se explican algunos de ellos.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 123 de 189
a.) Tamaño y posición del componente
ΠDimension getSize(), Devuelve la anchura y altura del componente como un objeto
de la clase Dimension, que tiene como campos: wiath (anchura) y heigth (altura).
Πvoia setSize(int ancho. int largo), Establece la anchura y altura del componente.
Œ Dimension getPreferreaSize(), Devuelve el tamaño que este componente debería
tener.
Œ voia setPreferreaSize(), Establece el tamaño que este componente debería tener.
Œ Dimension getMinimumSize(), Devuelve el tamaño mínimo que este componente
debería tener.
Œ voia setMinimumSize(int ancho. int largo), Establece el tamaño mínimo que este
componente debería tener.
ΠRectangle getBounas(), Devuelve las coordenadas de este componente como un
objeto de la clase Rectangle, que tiene como campos: x. v. wiath v heigth.
Πvoia setBounas(int x. int v. int ancho. int largo), Establece las coordenadas de este
componente.
b.) Acciones sobre el componente
Œ boolean getEnablea(), Comprueba si el componente está o no activo.
Πvoia setEnablea(boolean), Establece el componente a activo o inactivo.
Œ boolean getJisible(), Comprueba si el componente está o no visible.
Œ voia setJisible(boolean), Establece si el componente está visible o invisible.
Πvoia paint(Graphics g), Indica al AWT que ha de dibujar el componente g.
Πvoia repaint(), Indica al AWT que ha de volver a dibujar el componente.
Œ voia upaate(Graphics g), Es llamado por AWT cuando se invoca el método
repaint(). Por defecto llama a paint().
c.) Eventos de interacción con el usuario
A su vez hay tres tipos de métodos, para la gestión de eventos mediante el nuevo
modelo de eventos de AWT (desde la versión 1.1).
Hay tres tipos de métodos:
Œ voia aaaTipoListener(TipoListener l), Añade un oyente a la espera de algún
tipo de eventos sobre este componente.
Œ voia removeTipoListener(TipoListener l), Elimina algún oyente que estaba a la
espera de algún tipo de eventos sobre este componente.
Πvoia processTipoEvent(TipoEvent e), Procesa eventos del tipo _TipoEvent
enviándolos a cualquier objeto _TipoListener que estuviera escuchando.
En estos métodos Tipo puede ser cualquiera de los siguientes:
Component. Focus, InputMethoa, Kev, Mouse, MouseMotion.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 124 de 189
C. CONTAINER
La clase Container sabe cómo mostrar componentes embebidos (que a su vez pueden
ser instancias de la clase Container).
Algunos de los métodos de la clase Container son:
Œ Component aaa(Component c), Añade un componente al contenedor.
Πvoia print(Graphics g), Imprime el contenedor.
Πvoia printComponents(Graphics g), Imprime cada uno de los componentes de este
contenedor.
Œ LavoutManager getLavout(), Devuelve el gestor de impresión (LavoutManager)
asociado a este contenedor, que es el responsable de colocar los componentes dentro
del contenedor.
Œ voia setLavout(LavoutManager 1), Establece un gestor de impresión para este
componente.
Estos objetos Container tienen un LavoutManager asociado que define la manera en
que van a posicionarse los objetos componentes en su interior.
D. GESTORES DE IMPRESIÓN
LavoutManager y LavoutManager2 son dos interfaces encargadas de la representación
y posicionamiento en pantalla de componentes AWT.
De estas interfaces se proporcionan cinco implementaciones en AWT. Cada una de ellas
reparte los objetos de una forma particular:
ΠBoraerLavout: En cinco lugares: Norte, Sur, Este, Oeste y Centro (North. South.
East. West y Center).
Œ CaraLavout: Permite gestionar varios componentes de los que sólo uno se visualiza
a la vez, permaneciendo los demás invisibles debajo.
Œ FlowLavout: De izquierda a derecha horizontalmente en cada línea. Cuando
sobrepasan una línea se comienza a la izquierda de la siguiente.
Œ GriaLavout: En una tabla en la que todas las casillas tienen el mismo tamaño.
Œ GriaBagLavout: En una tabla, pero las casillas no tienen que tener el mismo tamaño.
E. OTRAS CLASES
Por supuesto AWT no se limita a estas clases. Dentro de esta biblioteca podemos
encontrar multitud de clases prefabricadas para facilitar el diseño gráfico.
A continuación explicamos algunas de ellas.
a.) Clases contenedoras (hijas de Container
Œ Panel: Permite hacer una presentación más avanzada que Container mediante la
combinación con subpaneles o subclases para crear contenedores personalizados. La
clase Applet que sirve para crear applets Java, hereda de esta clase Panel.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 125 de 189
ΠScrollPane: Una barra de desplazamiento, horizontal o vertical.
ΠWinaow: Una ventana sin borde.
ΠFrame: Una ventana que no tiene borde. Puede tener asociado un objeto Menubar
(una barra de herramientas o barra de menú personalizada).
Œ Dialog: Una ventana usada para crear diálogos. Tiene la capacidad de ser moaal con
lo que sólo este contenedor recibiría entradas del usuario.
Œ Fileaialog: Un diálogo que usa el selector de archivos nativo del sistema operativo.
b.) Clases componentes (hijas directas de Component)
Œ Button: Un botón gráfico para el que se puede definir una acción que sucederá
cuando se presione el botón.
ΠCanvas: Permite pintar o capturar eventos del usuario. Se puede usar para crear
gráficos o como clase base para crear una jerarquía de componentes personalizados.
ΠCheckbox: Soporta dos estados: on y off. Se pueden asociar acciones que se ejecuten
(triggers) cuando el estado cambie.
Œ Choice: Menú desplegable de opciones.
Œ Label: Cadena de etiqueta en una localización dada.
ΠList: Una lista desplegable de cadenas.
ΠScrollbar: Desplegable de objetos Canvas.
ΠTextComponent: Cualquier componente que permita editar cadenas de texto.Tiene
dos clases hijas:
Œ TextFiela: Componente de texto consistente en una línea que puede ser usada
para construir formularios.
Œ TextArea: Componente para edición de texto de tamaño variable.
F. EVENTOS DE AWT
AWT tiene sus propios eventos, que se explican a continuación.
a.) Eventos físicos
Son todos hijos del evento ComponentEvent, que indica algún cambio en un objeto
Component:
ΠInputEvent: Se ha producido una entrada del usuario. Tiene como eventos hijos
KevEvent (pulsación de una tecla) y MouseEvent (acción sobre el ratón).
ΠFocusEvent: Avisa al programa de que el componente ha ganado o perdido la
atencion (enfoque) del usuario. Esto se deduce de la actividad del usuario (ratón y
teclado).
ΠWinaowEvent: Avisa al programa de que el usuario ha utilizado uno de los controles
de ventana a nivel del sistema operativo, como los controles de minimizar o cerrar.
Œ ContainerEvent: Se envía cuando se añaden o eliminan componentes a un
contenedor.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 126 de 189
Œ PaintEvent: Evento especial que señala que el sistema operativo quiere dibujar de
nuevo una parte de la interfaz. Un componente debe sobreescribir el método paint()
o el método upaate() para gestionar este evento.
b.) Eventos semánticos
Son todos hijos del evento AWTEvent, que es el evento base de la jerarquía de eventos:
Œ ActionEvent: Avisa al programa de acciones específicas de componentes como las
pulsaciones de botones.
ΠAaiustmenteEvent: Comunica que una barra de desplazamiento ha sido ajustada.
Œ ItemEvent: Avisa al programa cuando el usuario interacciona con una elección, una
lista o una casilla de verificación.
ΠTextEvent: Avisa cuando un usuario cambia texto en un componente
TextComponent. TextArea o TextFiela.
Œ InputMethoaEvent: Avisa que un texto que está siendo creado utilizando un método
de entrada está cambiando (se ha escrito algo más...).
Œ InvocationEvent: Este evento ejecuta el método run() en una clase Runnable cuando
es tratado por el threaa del despachador (aispatcher) de AWT.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 127 de 189
IV.3. SWING
A. INTRODUCCIÓN
El paquete Swing es el nuevo paquete gráfico que ha aparecido en la versión 1.2 de
Java. Está compuesto por un amplio conjunto de componentes de interfaces de usuario
que funcionen en el mayor número posible de plataformas.
Cada uno de los componentes de este paquete puede presentar diversos aspectos y
comportamientos en función de una biblioteca de clases. En la versión 1.0 de Swing,
que corresponde a la distribuida en la versión 1.2 de la API de Java se incluyen tres
bibliotecas de aspecto y comportamiento para Swing:
Πmetal.iar: Aspecto y comportamiento independiente de la plataforma.
Πmotif.iar: Basado en la interfaz Sun Motif.
Πwinaows.iar: Muy similar a las interfaces Microsoft Windows 95.
La siguiente imagen muestra una aplicación de ejemplo (adjunta al JDK 1.2) que
muestra las diferentes interfaces para una misma aplicación según se utilice una u otra
biblioteca:
Imagen 8. Diferentes aspectos ae una interfaz Swing
Es la nueva clase denominada UiManager la que se encarga del aspecto y
comportamiento de una aplicación Swing en un entorno de ejecución.
En el apartado "JI.3. Eiemplo ae creacion ae una applet" se muestra un breve ejemplo
de cómo utilizar las clases de Swing para crear una aplicación utilizando Swing.
B. NUEVAS CARACTERÍSTICAS
La arquitectura Swing presenta una serie de ventajas respecto a su antecedente AWT:
ΠAmplia variedad de componentes: En general las clases que comiencen por "J" son
componentes que se pueden añadir a la aplicación. Por ejemplo: JButton.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 128 de 189
ΠAspecto modificable (look ana feel): Se puede personalizar el aspecto de las
interfaces o utilizar varios aspectos que existen por defecto (Metal Max, Basic
Motif, Window Win32).
ΠArquitectura Modelo-Vista-Controlador: Esta arquitectura da lugar a todo un
enfoque de desarrollo muy arraigado en los entornos gráficos de usuario realizados
con técnicas orientadas a objetos. Cada componente tiene asociado una clase de
modelo de datos y una interfaz que utiliza. Se puede crear un modelo de datos
personalizado para cada componente, con sólo heredar de la clase Moael.
Œ Gestión mejorada de la entrada del usuario: Se pueden gestionar combinaciones de
teclas en un objeto KevStroke y registrarlo como componente. El evento se activará
cuando se pulse dicha combinación si está siendo utilizado el componente, la
ventana en que se encuentra o algún hijo del componente.
Œ Objetos de acción (action obiects): Estos objetos cuando están activados (enablea)
controlan las acciones de varios objetos componentes de la interfaz. Son hijos de
ActionListener.
ΠContenedores anidados: Cualquier componente puede estar anidado en otro. Por
ejemplo, un gráfico se puede anidar en una lista.
Œ Escritorios virtuales: Se pueden crear escritorios virtuales o "interfaz de múltiples
documentos" mediante las clases JDesktopPane y JInternalFrame.
ΠBordes complejos: Los componentes pueden presentar nuevos tipos de bordes.
Además el usuario puede crear tipos de bordes personalizados.
Œ Diálogos personalizados: Se pueden crear multitud de formas de mensajes y
opciones de diálogo con el usuario, mediante la clase JOptionPane.
Œ Clases para diálogos habituales: Se puede utilizar JFileChooser para elegir un
fichero, y JColorChooser para elegir un color.
Œ Componentes para tablas y árboles de datos: Mediante las clases JTable y JTree.
Œ Potentes manipuladores de texto: Además de campos y áreas de texto, se presentan
campos de sintaxis oculta JPasswora, y texto con múltiples fuentes JTextPane.
Además hay paquetes para utilizar ficheros en formato HTML o RTF.
ΠCapacidad para "deshacer": En gran variedad de situaciones se pueden deshacer las
modificaciones que se realizaron.
Œ Soporte a la accesibilidad: Se facilita la generación de interfaces que ayuden a la
accesibilidad de discapacitados, por ejemplo en Braille.
C. PRINCIPALES CLASES
Las clases de Swing se parecen mucho a las de AWT.
Todas las clases explicadas en el apartado "IV.2 AWT" de este tutorial tienen una nueva
versión en Swing con el prefijo J. Así la clase Panel de AWT tiene una clase JPanel en
Swing. Esto se cumple para todas las clases menos para Choice. Canvas. FileDialgog y
ScrollPane.
De hecho todas las clases componentes de Swing (clases hijas de JComponent), son
hijas de la clase Component de AWT.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 129 de 189
ΠButtonGroup: Muestra una lista de elementos (JRaaioButton) con solo uno
seleccionable. Cada elemento tiene un círculo, que en caso del elemento
seleccionado contendrá un "punto".
Œ JToggleButton: Es como un botón normal, pero al ser pinchado por el usuario queda
activado.
ΠJProgressBar: Representa una barra de estado de progreso, mediante la que
habitualmente se muestra el desarrollo de un proceso en desarrollo (ejemplo: la
instalación de una aplicación).
ΠJTabbeaPane: Es una ventana con solapas (la que utiliza Windows). Este
componente había sido muy solicitado.
Œ JApplet: Aunque ya existía una clase Applet en AWT, esta nueva versión es
necesaria para crear applets Java que utilicen interfaces Swing.
Por supuesto Swing no se limita a estas clases, sino que posee muchas más con diversas
funcionalidades. Para estudiarlas consulte la documentación del JDK 1.2 de Java.
D. NUEVOS GESTORES DE IMPRESIÓN
Swing incorpora nuevos gestores de impresión, ampliando los cinco que AWT
incorporaba. Entre ellos conviene destacar los siguientes:
Œ BoxLavout: Es similar al FlowLavout de AWT, con la diferencia de que con él se
pueden especificar los ejes (x o y). Viene incorporada en el componente Box, pero
está disponible como una opción en otros componentes.
Œ OverlavLavout: Todos los componentes se añaden encima de cada componente
previo.
Œ SpringLavout: El espacio se asigna en función de una serie de restricciones
asociadas con cada componente.
ΠScrollPaneLavout: Incorporado en el componente ScrollPane.
ΠJiewportLavout: Incorporado en el componente Jiewport.
E. JROOTPANE
La clase JRootPane permite colocar contenido de las applets creadas con la clase
JApplet en un determinado plano de impresión (capa).
Por orden de cercanía al usuario, estas capas son:
ΠglassPane: Una capa que abarca toda la parte visible (por defecto no es visible).
Œ lavereaPane: Una subclase de JComponent diseñada para contener cuadros de
diálogo, menús emergentes y otros componentes que deben aparecer flotando entre
el usuario y el contenido.
Œ menubar: Una capa opcional, que si aparece estará anclada en la parte superior.
Œ contenPane: La capa en que se dibujará la mayor parte del contenido.
Así pues cada vez que se vayan a añadir componentes a una applet de clase JApplet,
debe añadirse a uno de estas capas. Por ejemplo:
laJApplet.getContentPane().add( unComponente );
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 130 de 189
F. NUEVOS EVENTOS DE SWING
Swing incorpora su nuevo conjunto de eventos para sus componentes.
a.) Eventos físicos
Sólo aparecen dos nuevos eventos físicos, descendientes de InputEvent:
Œ MenuKevEvent: Un menú de árbol ha recibido un evento de KevEvent (acción sobre
el ratón).
Œ MenuDragMouseEvent: Un menú de árbol ha recibido un evento de MouseEvent
(pulsación de una tecla).
b.) Eventos semánticos
Son todos hijos del evento de AWT AWTEvent, que es el evento base de la jerarquía de
eventos:
Œ AncestorEvent: Antecesor añadido desplazado o eliminado.
Œ CaretEvent: El signo de intercalación del texto ha cambiado.
ΠChangeEvent: Un componente ha sufrido un cambio de estado.
ΠDocumentEvent: Un documento ha sufrido un cambio de estado.
Œ HvperlinkEvent: Algo relacionado con un vínculo hipermedia ha cambiado.
Œ InternalFrameEvent: Un AWTEvent que añade soporte para objetos JInternalFrame.
Œ ListDataEvent: El contenido de una lista ha cambiado o se ha añadido o eliminado
un intervalo.
Œ ListSelectionEvent: La selección de una lista ha cambiado.
Œ MenuEvent: Un elemento de menú ha sido seleccionado o mostrado o bien no
seleccionado o cancelado.
ΠPopupMenuEvent: Algo ha cambiado en JPopupMenu.
ΠTableColumnMoaelEvent: El modelo para una columna de tabla ha cambiando.
ΠTableMoaelEvent: El modelo de una tabla ha cambiado.
Œ TreeExpansionEvent: El nodo de un árbol se ha extendido o se ha colapsado.
Œ TreeMoaelEvent: El modelo de un árbol ha cambiado.
Œ TreeSelectionEvent: La selección de un árbol ha cambiado de estado.
Œ UnaoableEaitEvent: Ha ocurrido una operación que no se puede realizar.
G. EL PATRÓN DE DISEÑO MODELO-VISTA-CONTROLADOR
Muchos de los componentes Swing están basados en un patrón de diseño denominado
"Modelo-Vista-Controlador".
El concepto de este patrón de diseño se basa en tres elementos:
ΠModelo: Almacena el estado interno en un conjunto de clases.
Œ Vista: Muestra la información del modelo
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 131 de 189
Œ Controlador: Cambia la información del modelo (delegado).
No es menester de este tutorial explicar todo el funcionamiento de este nuevo diseño,
pero si se quiere profundizar en él consulte }Morgan, 1999].
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 132 de 189
TEMA V. JAVA E INTERNET
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 133 de 189
V.1 JAVA E INTERNET
A. INTRODUCCIÓN
Una de las grandes potencias del lenguaje de programación Java es la total portabilidad
de sus programas gracias a su afamada “máquina virtual”. Esto adquiere una
importancia aún mayor en Internet donde existen tipos de computadoras muy dispares.
Las siguientes bibliotecas de la API de Java contienen una serie de clases que son
interesantes de cara a la creación de aplicaciones que trabajen en red. Las más
importantes son:
Πiava.applet: Da soporte a las applets.
Πiava.net: Clases para redes. Dan acceso a TCP/IP, sockets y URLs.
Conviene destacar la existencia de otras bibliotecas más complejas, orientadas también
a la programación en red, que aunque no serán estudiadas en este tutorial, sí conviene
tener presente su existencia:
Œ iava.sql: Paquete que contiene el JDBC, para conexión de programas Java con
Bases de datos.
Πiava.rmi: Paquete RMI, para localizar objetos remotos, comunicarse con ellos e
incluso enviar objetos como parámetros de un objeto a otro.
Œ org.omg.CORBA: Facilita la posibilidad de utilizar OMG CORBA, para la conexión
entre objetos distribuidos, aunque estén codificados en distintos lenguajes.
Πorg.omb.CosNaming : Da servicio al IDL de Java, similar al RMI pero en CORBA.
Una de las características de Java que lo hacen especialmente interesante para Internet
es que sus programas objeto (códigos de byte) son verificables para poder detectar
posibles virus en sus contenidos. Estos programas Coaigos ae bvte no necesitan ser
recompilados, y una vez verificados (pues Java trabaja con nombres no con
direcciones), se transforman en direcciones físicas de la máquina destino.
Imagen 9. Eiecucion ae un coaigo ae bvte
Esta forma de trabajar cuida la seguridad sin un grave perjuicio de la eficiencia. Un
programa en Java es sólo unas 20 veces más lento que uno programado en C, cifra
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 134 de 189
aceptable para la mayoría de las tareas, y suponiendo que no se utilice un compilador
JIT.
B. EL PAQUETE JAVA.NET
Java ofrece un conjunto de clases que permiten utilizar los URLs (Uniform Resource
Locators). Un URL es una dirección electrónica que permite encontrar una información
en Internet especificando:
Œ El nombre del protocolo que permitirá leer la información. Por ejemplo HTTP.
Œ El nombre del servidor que proporciona la información. Por ejemplo sunsite.unc.eau
o bien una dirección IP directamente.
ΠEl nombre del fichero en el servidor. Por ejemplo /Javafaq/Javafaq.htm.
C. FUTURO DEL JAVA EN INTERNET
Java es seguramente el lenguaje con más futuro en cuanto a la programación para
Internet.
De hecho, podría evolucionar hasta el punto de que el navegador no interprete las
applets de Java, sino que él sea un conjunto de applets que se descarguen de Internet
según se vayan necesitando. Así es que en todo momento podríamos estar ejecutando la
última versión del navegador.
Incluso siendo un poco más futuristas, podríamos plantearnos conectarnos a servidores
que nos cobraran por el uso de sus programas (hojas de cálculo, procesadores de
texto...) en función del tiempo de uso, trabajando siempre con la última versión del
mismo, en lugar de invertir nuestro dinero en actualizaciones.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 135 de 189
V.2 LOS SOCKETS EN JAVA
A. FUNDAMENTOS
Los sockets son un sistema de comunicación entre procesos de diferentes máquinas de
una red. Más exactamente, un socket es un punto de comunicación por el cual un
proceso puede emitir o recibir información.
Fueron popularizados por Bercklev Software Distribution, de la universidad
norteamericana de Berkley. Los sockets han de ser capaces de utilizar el protocolo de
streams TCP (Transfer Contro Protocol) y el de datagramas UDP (User Datagram
Protocol).
Utilizan una serie de primitivas para establecer el punto de comunicación, para
conectarse a una máquina remota en un determinado puerto que esté disponible. para
escuchar en él, para leer o escribir y publicar información en él, y finalmente para
desconectarse.
Con todas primitivas se puede crear un sistema de diálogo muy completo.
Imagen 10. Funcionamiento ae una conexion socket
Para más información véase }Rifflet, 1998].
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 136 de 189
B. EJEMPLO DE USO
Para comprender el funcionamiento de los sockets no hay nada mejor que estudiar un
ejemplo. El que a continuación se presenta establece un pequeño diálogo entre un
programa servidor y sus clientes, que intercambiarán cadenas de información.
a.) Programa Cliente
El programa cliente se conecta a un servidor indicando el nombre de la máquina y el
número puerto (tipo de servicio que solicita) en el que el servidor está instalado.
Una vez conectado, lee una cadena del servidor y la escribe en la pantalla:
import java.io.*;
import java.net.*;
class Cliente {
static final String HOST = "localhost";
static final int PUERTO=5000;
public Cliente( ) {
try{
Socket skCliente = new Socket( HOST , Puerto );
InputStream aux = skCliente.getInputStream();
DataInputStream flujo = new DataInputStream( aux );
System.out.println( flujo.readUTF() );
skCliente.close();
} catch( Exception e ) {
System.out.println( e.getMessage() );
}
}
public static void main( String[] arg ) {
new Cliente();
}
}
En primer lugar se crea el socket denominado skCliente, al que se le especifican el
nombre de host (HOST) y el número de puerto (PORT) en este ejemplo constantes.
Luego se asocia el flujo de datos de dicho socket (obtenido mediante getInputStream)),
que es asociado a un flujo (fluio) DataInputStream de lectura secuencial. De dicho flujo
capturamos una cadena ( reaaUTF() ), y la imprimimos por pantalla (Svstem.out).
El socket se cierra, una vez finalizadas las operaciones, mediante el método close().
Debe observarse que se realiza una gestión de excepción para capturar los posibles
fallos tanto de los flujos de datos como del socket.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 137 de 189
b.) Programa Servidor
El programa servidor se instala en un puerto determinado, a la espera de conexiones, a
las que tratará mediante un segundo socket.
Cada vez que se presenta un cliente, le saluda con una frase "Hola cliente N".
Este servidor sólo atenderá hasta tres clientes, y después finalizará su ejecución, pero es
habitual utilizar bucles infinitos ( while(true) ) en los servidores, para que atiendan
llamadas continuamente.
Tras atender cuatro clientes, el servidor deja de ofrecer su servicio:
import java.io.* ;
import java.net.* ;
class Servidor {
static final int PUERTO=5000;
public Servidor( ) {
try {
ServerSocket skServidor = new ServerSocket( PUERTO );
System.out.println("Escucho el puerto " + PUERTO );
for ( int numCli = 0; numCli < 3; numCli++; ) {
Socket skCliente = skServidor.accept(); // Crea objeto
System.out.println("Sirvo al cliente " + numCli);
OutputStream aux = skCliente.getOutputStream();
DataOutputStream flujo= new DataOutputStream( aux );
flujo.writeUTF( "Hola cliente " + numCli );
skCliente.close();
} // Cierra while
System.out.println("Demasiados clientes por hoy");
} catch( Exception e ) {
System.out.println( e.getMessage() );
}
}
public static void main( String[] arg ) {
new Servidor();
}
}
Utiliza un objeto de la clase ServerSocket (skServiaor), que sirve para esperar las
conexiones en un puerto determinado (PUERTO), y un objeto de la clase Socket
(skCliente) que sirve para gestionar una conexión con cada cliente.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 138 de 189
Mediante un bucle for y la variable numCli se restringe el número de clientes a tres, con
lo que cada vez que en el puerto de este servidor aparezca un cliente, se atiende y se
incrementa el contador.
Para atender a los clientes se utiliza la primitiva accept() de la clase ServerSocket, que
es una rutina que crea un nuevo Socket (skCliente) para atender a un cliente que se ha
conectado a ese servidor.
Se asocia al socket creado (skCliente) un flujo (fluio) de salida DataOutputStream de
escritura secuencial, en el que se escribe el mensaje a enviar al cliente.
El tratamiento de las excepciones es muy reducido en nuestro ejemplo, tan solo se
captura e imprime el mensaje que incluye la excepción mediante getMessage().
c.) Ejecución
Aunque la ejecución de los sockets está diseñada para trabajar con ordenadores en red,
en sistemas operativos multitarea (por ejemplo Windows y UNIX) se puede probar el
correcto funcionamiento de un programa de sockets en una misma máquina.
Para ellos se ha de colocar el servidor en una ventana, obteniendo lo siguiente:
>java Servidor
Escucho el puerto 5000
En otra ventana se lanza varias veces el programa cliente, obteniendo:
>java Cliente
Hola cliente 1
>java Cliente
Hola cliente 2
>java Cliente
Hola cliente 3
>java Cliente
connection refused: no further information
Mientras tanto en la ventana del servidor se ha impreso:
Sirvo al cliente 1
Sirvo al cliente 2
Sirvo al cliente 3
Demasiados clientes por hoy
Cuando se lanza el cuarto de cliente, el servidor ya ha cortado la conexión, con lo que se
lanza una excepción.
Obsérvese que tanto el cliente como el servidor pueden leer o escribir del socket. Los
mecanismos de comunicación pueden ser refinados cambiando la implementación de los
sockets, mediante la utilización de las clases abstractas que el paquete iava.net provee.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 139 de 189
TEMA VI: APPLETS JAVA
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 140 de 189
VI.1. INTRODUCCIÓN A LAS APPLETS
A. INTRODUCCIÓN
Las applets (miniaplicación) son programas escritos en Java que sirven para “dar vida”
a las páginas Web (interacción en tiempo real, inclusión de animaciones, sonidos...), de
ahí su potencia.
Las applets son programas que se incluyen en las páginas Web. Las applets son
ejecutadas en la máquina cliente, con lo que no existen ralentizaciones por la saturación
del módem o del ancho de banda. Permiten cargar a través de la red una aplicación
portable que se ejecuta en el navegador. Para que esto ocurra tan sólo hace falta que el
navegador sea capaz de interpretar Java.
A las páginas que contienen applets se las denomina páginas Java-Powerea. Las applets
pueden ser visualizadas con la herramienta appletviewer, incluido en el JDK de Java.
Las applets no son exactamente aplicaciones Java, ya que presentan las siguientes
diferencias respecto a las aplicaciones normales Java:
Se cargan mediante un navegador, no siendo lanzados por el intérprete Java.
Son cargados a través de la red por medio de páginas HTML y no residen en el disco
duro de la máquina que los ejecuta.
Poseen un ciclo de vida diferente; mientras que una aplicación se lanza una vez, una
applet se arranca (inicia) cada vez que el usuario recarga la página en la que se
encuentra la applet.
Tienen menos derechos que una aplicación clásica, por razones de seguridad. De modo
predeterminado en el puesto que los ejecuta no pueden ni leer ni escribir ficheros, ni
lanzar programas, ni cargar DLLs. Sólo pueden comunicarse con el servidor Web en
que se encuentra la página Web que las contiene.
B. CONSIDERACIONES SOBRE LA SEGURIDAD EN LAS APPLETS
Como ya se ha dicho las applets tienen una serie de restricciones de programación que
las hacen "seguras".
Estas restricciones de seguridad son especialmente importantes, ya que evitarán que se
cargue por error una applet que destruya datos de la máquina, que obtenga información
restringida, o que produzca otros daños inesperados.
Las applets no dejan de ser “ejecutables” que funcionan dentro de una aplicación, como
puede ser un visualizador de páginas Web (browser). Este ejecutable puede obtenerse
de una red, lo que significa que hay código posiblemente no fiable que se ejecuta dentro
de la aplicación.
Java tiene muchas salvaguardas de seguridad que minimizan el riesgo de la ejecución de
applets, pero estas salvaguardas también limitan a los programadores de applets en su
capacidad de programación.
El modelo de seguridad para las applets en Java trata una applet como código no fiable
ejecutándose dentro de un entorno fiable. Por ejemplo, cuando un usuario instala una
copia de un navegador Web en una máquina se está fiando de que su código será
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 141 de 189
funcional en el entorno. Normalmente los usuarios tienen cuidado de qué instalan
cuando proviene de una red. Una applet, por el contrario, se carga desde la red sin
ninguna comprobación de su fiabilidad.
El lenguaje Java y las applets son escritos para que eviten las applets no fiables.
Estas salvaguardas son implementadas para verificar que los códigos de byte de las
clases de los applets, no rompen las reglas básicas del lenguaje ni las restricciones de
acceso en tiempo de ejecución. Sólo cuando estas restricciones son satisfechas se le
permite a la applet ejecutar su código. Cuando se ejecuta, se le marca para señalar que
se encuentra dentro del intérprete. Esta marca permite a las clases de tiempo de
ejecución determinar cuándo a una fracción del código se le permite invocar a cierto
método. Por ejemplo, una applet está restringida en los hosts en los que se puede abrir
una conexión de red o en un conjunto de URLs a las que puede acceder.
En su conjunto estas restricciones constituyen una política de seguridad. En el futuro,
Java tendrá políticas más ricas, incluyendo algunas que usen encriptación y
autentificación para permitir a las applets una mayor capacidad.
La actual política de seguridad afecta a los recursos que una applet puede usar, cuyos
principales puntos son:
ΠLos accesos que pueden realizar las applets a los ficheros son restringidos. En
particular escribir en ficheros y/o leerles no será una capacidad estándar que se
pueda realizar en los navegadores que soporten applets de Java.
Œ Las conexiones de red serán restringidas a conectar solo con el host del que proviene
la applet.
Œ Una applet no es capaz de usar ningún método que pueda resultar en una ejecución
arbitraria, código no revisado o ambos. Esto incluye métodos que ejecuten
programas arbitrarios (métodos nativos) así como la carga de bibliotecas dinámicas.
Se anticipa en cualquier caso que en el futuro los modelos de seguridad permitirán a las
applets autentificadas superar estas restricciones.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 142 de 189
VI.2. LA CLASE APPLET
A. SITUACIÓN DE LA CLASE APPLET EN LA API DE JAVA
La clase Applet Java, de la cual han de heredar todos los programas Java que vayan a
actuar como applets, es la única clase que contiene el paquete iava.applet de la API de
Java.
Esta clase hereda de Obiect (como todas las clases Java), pero además hereda de
Component y Container, que son dos clases del paquete gráfico AWT. Esto ya perfila
las posibilidades gráficas de este tipo de aplicaciones Java.
B. MÉTODOS DEL CICLO DE VIDA
Como ya se ha indicado una applet no tiene un ciclo de vida tan "sencillo" como el de
una aplicación, que simplemente se ejecuta hasta que finaliza su método main().
La siguiente figura modeliza el ciclo de vida de una applet:
Imagen 11. Ciclo ae viaa ae una applet
Cada círculo representa una fase en el ciclo de vida de la applet. Las flechas representan
transiciones y el texto representa la acción que causa la transición. Cada fase está
marcada con una invocación a un método de la applet:
Œ voia init(), Es invocado cuando se carga la applet. Aquí se suelen introducir las
iniciaciones que la applet necesite.
Œ voia start(),Es invocado cuando la applet, después de haber sido cargada, ha sido
parada (cambio de página Web, minimización del navegador,...), y de nuevo
activada (vuelta a la página, restauración del navegador,...). Se informa a la applet
de que tiene que empezar su funcionamiento.
Œ voia stop(), Es invocado para informar a la applet de que debe de parar su ejecución.
Así una applet que utilice threaas, debería detenerlos en el código de este método.
Œ voia aestrov(),Es invocado para informar a la applet de que su espacio está siendo
solicitado por el sistema, es decir el usuario abandona el navegador. La applet debe
de aprovechar este momento para liberar o destruir los recursos que está utilizando.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 143 de 189
Πvoia paint(), Es invocado cada vez que hay que el navegador redibuja la applet.
Al crear una applet no es necesario implementar todos estos métodos. De hecho habrá
applets que no los necesiten.
Cuando un navegador carga una página Web que contiene una applet, suele mostrar en
su parte inferior un mensaje como:
initializing... starting...
Esto indica que la applet, se está cargando:
1. Una instancia de la clase applet es creada.
2. La applet es iniciada, mediante su método init().
3. La applet empieza a ejecutarse, mediante su método start().
Cuando el usuario se encuentra con una página Web, que contiene una applet y salta a
otra página, entonces la applet se detiene invocando a su método stop(). Si el usuario
retorna a la página donde reside la applet, ésta vuelve a ejecutarse nuevamente
invocando a su método start().
Cuando el usuario sale del navegador la applet tiene un tiempo para finalizar su
ejecución y hacer una limpieza final, mediante el método aestrov().
C. LA CLASE URL
Un URL (Uniform Resource Locator) es una dirección de Internet. Cada recurso
(fichero, página Web, imagen...) tiene uno propio. En Java existe una clase denominada
URL que modeliza esta clase de objetos.
La clase URL pertenece al paquete iava.net, y tiene una cierta importancia en el
desarrollo de las applets, puesto que muchos de los métodos de la clase Applet la
utilizan para acceder a determinado recurso de Internet o para identificarse.
Podemos especificar un URL de manera absoluta:
URL URLabsoluto = new URL(“http://www.host.com/dir/fich.htm”);
O bien podemos especificar un URL de manera relativa:
URL URLhost = new URL(“http://www.Javasoft.com/”);
URL URLrelativo = new URL( URLhost, “dir/fich.htm”);
Ambos ejemplos corresponderían al URL "http.//www.host.com/air/fich.htm".
D. INCLUSIÓN DE LA APPLET EN UNA PÁGINA WEB
Para incluir una applet en una página Web, una vez compilada la applet, debe incluirse
entre el código HTML de la página Web una etiqueta ·APPLET~, que como mínimo
ha de presentar los siguientes tres parámetros:
Πcoae: Especifica el URL del fichero de clase Java (*.class) que contiene la applet.
Πwidth: Especifica la anchura inicial de la applet (en pixels).
Πheigth: Especifica la altura inicial de la applet (en pixels).
Además, de la etiqueta inicial, una applet puede tener parámetros que se especificarán
mediante etiquetas ·PARAM~, que como mínimo han de presentar dos parámetros:
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 144 de 189
Œ name: Indica el nombre del parámetro de la applet al que esta etiqueta hace
referencia.
Œ value: Establece este valor al parámetro indicado en name de la misma etiqueta.
Así un ejemplo de esto sería:
<applet code="AppletDiagonal.class" width=200 height=200>
<param name=Parametro1 value=Valor1>
<param name=Parametro2 value=Valor2>
</applet>
En este ejemplo la applet puede entender los parámetro Parametro1 y Parametro2,
mediante los métodos que se describen en el siguiente apartado, y obtendría Jalor1 y
Jalor2 respectivamente.
Se observa que además de la etiqueta ·applet~ en el código HTML también aparece
una etiqueta ·/applet~. Esto sucede porque HTML es un lenguaje pareado, en el que
casi todas las etiquetas de inicio de elemento (·etiq~) tienen una etiqueta de fin
(·/etiq~).
E. OBTENCIÓN DE LOS PARÁMETROS DE LA APPLET
Cuando se incluye una applet en una página Web ha de hacerse mediante la etiqueta
HTML ·applet~. Las etiquetas HTML permiten utilizar parámetros, y la etiqueta
·applet~ hace lo propio, permitiendo a la applet recibir parámetros de ejecución, tal y
como una aplicación los recibe en el parámetro s (un vector de cadenas) de su método
main(String[{ s).
Los siguientes métodos se utilizan para extraer información de los parámetros que
recibió la applet cuando fue llamada desde el código HTML:
ΠURL getDocumentBase(), Devuelve el URL del documento que contiene la applet.
ΠURL getCoaeBase(), Devuelve el URL de la applet.
Œ String getParameter(String name), Devuelve el valor de un parámetro (etiquetas
·param~) que aparezca en el documento HTML.
Si por ejemplo se llamase a una applet, con el código HTML:
<applet code=”AppletParam.class” width=50 height=50>
<param name=Color value=”red”>
</applet>
Una llamada en esta applet al método getParameter('Color`) devolverá 'rea`.
F. OBTENCIÓN DE INFORMACIÓN SOBRE UNA APPLET
Algunos métodos de la applet se utilizan para comunicar información o mostrar
mensajes en la pantalla referentes a la applet:
Œ boolean isActive(), Comprueba si la applet está activa.
Πvoia showStatus(String status), Muestra una cadena del estado en la pantalla.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 145 de 189
Œ String getAppletInfo(); Devuelve información relativa a la applet como el autor,
Copyright o versión.
Œ String[ {[ { getParameterInfo(), Devuelve un vector que describe algún parámetro
específico de la applet. Cada elemento en el vector es un vector de tres cadenas que
tienen la forma: {nombre, tipo, comentario}.
Un ejemplo de como definir este método para una applet que permita un solo
parámetro, color, sería:
public String[][] getParameterInfo() {
String info[][] = { {“Color”,“String”,“foreground color”} };
return info;
}
G. MANIPULACIÓN DEL ENTORNO DE UNA APPLET
Algunas applets pueden afectar al entorno en que están ejecutándose. Para ello se
utilizan los métodos:
ΠAppletContext getAppletContext(), Devuelve un AppletContext, que permite a la
applet afectar a su entorno de ejecución.
Œ voia resize( int ancho. int largo), Solicita que se modifique el tamaño de la applet.
También permite recibir un único parámetro Dimension.
ΠLocale getLocale(), Devuelve el Locale de la applet si fue establecido.
Πvoia setStub( AppletStub s ), Establece el stub de esta applet.
H. SOPORTE MULTIMEDIA
La clase Applet también incluye métodos para trabajar con imágenes y ficheros de
sonido de Internet mediante la utilización de URLs. Para ello implementa los métodos:
Œ Image getImage(URL u. String s), Obtiene una imagen de un URL u que será
absoluto si no se especifica una ruta relativa s.
ΠAuaioClip getAuaioClip(URL u. String s), Obtiene un clip de sonido de un URL u
que será absoluto si no se especifica una ruta relativa s.
Πvoia plav(URL ur1. String name), Ejecuta directamente un fichero de sonido de un
URL u que será absoluto si no se especifica una ruta relativa s.
Πstatic auaioClip newAuaioClip(URL u), Obtiene un nuevo fichero de sonido del
URL u.
Mediante el uso adecuado de varios de estos métodos se pueden combinar sonidos e
imágenes para conseguir efectos espectaculares.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 146 de 189
VI.3. EJEMPLO DE CONSTRUCCIÓN DE UNA APPLET
A. CÓDIGO
Para crear una applet normalmente será necesario importar al menos las bibliotecas
iava.awt.' y la iava.applet.'.
La clase que represente a la applet se ha de declarar como una subclase de la clase
Applet, para poder sobreescribir los métodos de la clase Applet.
Siempre conviene sobreescribir al menos el método paint() que será llamado por los
navegadores que soporten applets para mostrarles por pantalla.
Vamos a construir una applet denominada AppletDiagonal que simplemente dibuje una
línea diagonal. Un posible código para esta applet sería:
import java.awt.*;
import java.applet.*;
public class AppletDiagonal extends Applet {
public void paint(Graphics g) {
g.setColor( Color.red );
g.drawLine(0, 0, getWidth(), getHeight() );
}
}
Pasemos a comentar el funcionamiento de este código:
Œ El método paint() recibe un objeto de la clase Graphics. La clase Graphics, incluida
en el AWT, contiene métodos para mostrar varios tipos de gráficos.
Œ Mediante el método setColor() de la clase Graphics se establece el color de primer
plano a rojo, que es uno de los colores predefinidos de la clase Color.
Œ Por último, mediante arawLine() se dibuja una línea dadas las coordenadas de su
esquina superior izquierda y de la inferior derecha. En este caso se indican la
esquina superior izquierda de la applet mediante las coordenadas (0.0), y la esquina
inferior derecha se obtiene mediante dos métodos de la clase Dimension (
getWiath(). getHeight() ).
B. EJECUCIÓN
Para ejecutar la applet, una vez compilado el fichero, se introduce la llamada a la applet
en una página Web (por ejemplo AppletDiagonal.htm), introduciendo entre su código
HTML lo siguiente:
<applet code="AppletDiagonal.class" width=200 height=200>
</applet>


Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 147 de 189
Cuando se cargue esta página Web en un navegador compatible con Java o mediante el
visualizador de applets que viene con el JDK (appletviewer) se verá algo como:
Imagen 12. Applet “Línea”
Se podría dibujar un rectángulo con cambiar la línea de código de arawLine() por otra
que llamase al método arawRect():
g.drawRect(10, 10, r.width –20, r.height –20);
C. CREACIÓN DE APPLETS MÁS AVANZADAS
La creación de applets complejos, escapa a las intenciones de este tutorial, con lo que
no se va a presentar el código fuente de más applets.
El dominio de la biblioteca AWT es una condición imprescindible para la creación de
applets de más calidad y vistosidad.
Por último recordar que con el JDK se incluyen unas cuantas applets que pueden servir
para el estudio de las mismas, puesto que se incluye su código fuente.
Para más información consulte }van Hoff et al., 1996].
D. CREACIÓN DE UNA APLICACIÓN QUE UTILICE LA APPLET (AWT)
Se va a utilizar AWT para crear una aplicación que de un resultado igual que la
ejecución de la "applet Linea". Será una aplicación que creará un Frame de AWT para
incluir en su interior la applet que ya fue creada.
De hecho el main() de la aplicación lo único que hará será crear un objeto de este tipo
(indicándole altura y anchura, como hacíamos en la applet mediante los parámetros de
la etiqueta HTML).
El código fuente de la aplicación sería el siguiente:
import java.awt.*;
import java.awt.event.*;

class FrameLinea extends Frame {
private AppletDiagonal unaApplet; // Se mostrará
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 148 de 189
public static void main( String[] s ) {
new FrameLinea( 200, 230 );
}
public FrameLinea( int ancho, int largo ) {
super(); // Constructor de Component
// Se añade un oyente que cerrara la aplicación
addWindowListener( new OyenteLinea() );
// Se crea una applet de diagonal
unaApplet=new AppletDiagonal();
unaApplet.init();
unaApplet.start();
// Se mete la applet en frame
add( unaApplet );
setSize(ancho,largo); // ajusta frame
setVisible(true); // muestra frame
}
// Clase anidada
class OyenteLinea extends WindowAdapter {
// Sobreescribo el método de "cuando se cierra ventana"
public void windowClosing(WindowEvent e) {
unaApplet.stop();
unaApplet.destroy();
System.exit(0);
}
}
}
Vamos a crear un Frame en el que vamos a incluir la applet unaApplet que será de la
clase AppletDiagonal, creada anteriormente.
La aplicación lo que hace es crear un oyente de la clase creada OventeLinea, que será el
encargado de capturar el evento de cerrar la ventana del Frame.
En el constructor se inicia la applet (init() y start()) y se añade al Frame mediante el
método aaa() de la clase Container (Frame es hija de Container).
Por último se establece el tamaño del Frame (recibido por parámetro) mediante setSize()
y por último se muestra el Frame que ya tiene en su interior la applet (setJisible()).
Cuando se cierra la ventana, el OventeLinea se encarga de cerrar la applet. mediante
stop() y aestrov(). y de finalizar la aplicación mediante Svstem.exit().
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 149 de 189
E. CREACIÓN DE UNA APLICACIÓN QUE UTILICE LA APPLET (SWING)
Esta misma aplicación se puede crear utilizando Swing con solo cambiar las siguientes
cosas:
1. Se ha de incluir la biblioteca de Swing:
import javax.swing.*;
2. Se han de cambiar los nombres de la clase Frame de AWT por la clase JFrame de
Swing.
3. Se crea un contentPane mediante un objeto JPanel, justo antes de llamar al oyente:
setContentPane( new JPanel() );
4. Para añadir la applet se ha de añadir al contentPane:
getContentPane().add( unaApplet );
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 150 de 189
VI.4. EJEMPLOS DE APPLETS
En este apartado se comentan una serie de applets que pueden servir tanto para
demostrar las posibilidades de estos programas, como para clasificarles por los
siguientes géneros:
Œ Instantáneas: Muestran una secuencia de imágenes.
Œ Animación y Sonidos: Mezclan imágenes con sonidos.
Œ Gráficos Interactivos: Permiten la interacción del usuario con las imágenes,
mediante respuestas a las acciones del ratón sobre la imagen.
Œ Trucos de Texto: Permiten animar texto dándole ‘vida’.
ΠFinancias y Negocios: Algunos nos permiten mostrar diagramas de barras, y otros
elementos ilustrativos de este género.
ΠDemos, Juegos y Educacionales: Muy especializados, permiten al usuario
interactuar consiguiendo cotas fascinantes de diversión.
A continuación veremos un ejemplo de cada grupo que sea lo más significativo posible,
es decir, que resalte las características de ese grupo y las diferencias con el resto de los
grupos.
En cada uno de ellos se ha incluido una descripción de lo que hace la applet, los
parámetros que soporta, y un ejemplo del código HTML que habría que insertar en una
página Web para incluir la applet en dicha página.
A. INSTANTÁNEAS: "TUMBLING DUKE"
Imagen 13. Applet Instantanea 'Tumbling Duke`
a.) Descripción
Se trata de una applet en la que Duke. la mascota de Java, da volteretas en la página
correspondiente. La animación consta de 17 secuencias.
b.) Parámetros
Œ maxwiath: Anchura máxima de la imagen durante la animación.
Œ nimgs: Número de marcos o secuencias en la animación.
Œ offset: Desplazamiento horizontal entre la primera y la última secuencia de la
animación.
Πimg: URL del directorio donde se encuentran almacenadas las diferentes secuencias
de la animación: T1.gif, T2.gif...
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 151 de 189
c.) Ejemplo
<applet code=”TumbleItem.class” width=600 height=95>
<param name=maxwidth value=”120”>
<param name=nimgs value=”16”>
<param name=offset value=”-57”>
<param name=img value=”tumble”>
</applet>
B. ANIMACIÓN Y SONIDO: "ANIMATOR"
Imagen 14. Applet ae Animacion v soniao 'Animator`
a.) Descripción
Esta applet permite crear una animación con sonido.
Se puede especificar el orden de las secuencias, si la animación se repite, la pista de
sonido, otros sonidos para determinadas secuencias, el espacio de tiempo entre
secuencias, una imagen por defecto mientras se está iniciando la applet, la posición
exacta en la que se quiere que aparezca cada secuencia...
Haciendo un clic con el ratón sobre la applet se detiene la animación. Haciendo otro
continúa la ejecución.
b.) Parámetros
Œ imagesource: URL del directorio que contiene las imágenes de la animación:
T1.gif...
Œ startup: URL de la imagen que aparecerá por defecto mientras se cargan el resto de
las secuencias.
Πbackgrouna: URL de la imagen de fondo.
Œ startimage: Índice de la primera secuencia.
Œ enaimage: Índice de la última secuencia de la animación.
Πpauses: Lista de las pausas en milisegundos. Permite especificar una pausa
específica para cada secuencia. Cada número se separa mediante el carácter |.
Œ repeat: Indicador de repetición. Se una para repetir la secuencia de animaciones. Su
valor por defecto es true.
Œ positions: Coordenadas de la posición de cada marco o secuencia (x@y). Permite
mover la animación alrededor. Cada par de coordenadas se separa por el carácter |.
Œ images: Índices de las imágenes. Permite repetir las imágenes de la animación. Cada
número se encuentra separado por el carácter |.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 152 de 189
Πsounasource: URL del directorio que contiene los archivos de sonido.
Œ sounatrack: URL del archivo de sonido que suena “de fondo”.
Πsounas: Lista de URLs de archivos de sonido para cada secuencia de la applet. Se
encuentran separados por el carácter |.
c.) Ejemplo
<applet code=Animator.class width=64 height=64>
<param name=imagesource value=”tower”>
<param name=endimage value=2>
<param name=soundsource value=”audio”>
<param name=soundtrack value=spacemusic.au>
<param name=sounds value=”1.au|2.au”>
<param name=pause value=200>
</applet>
C. GRÁFICOS INTERACTIVOS: "LINK BUTTON"
Imagen 15. Applet ae graficos interactivos 'Link Button`
a.) Descripción
Esta applet permite colocar un botón en una página Web. Cuando se pulse el botón
aparecerá una nueva página, o se reproducirá un determinado archivo de sonido,...
b.) Parámetros
Πhref: URL del documento o archivo al que hay que llamar cuando un usuario pulsa
el botón. Este URL también puede hacer referencia a una posición concreta de la
página actual.
Œ sna: URL del archivo de sonido que se va a reproducir cuando se pulse el botón.
c.) Ejemplo
<applet code=LinkButton.Java width=100 height=30>
<param name=lbl value=”Java”>
<param name=href value=http://www.Javasoft.com/>
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 153 de 189
<param name=snd value=”computer.au”>
</applet>
D. TRUCOS DE TEXTO: "NERVOUS TEXT"
Imagen 16. Applet ae texto animaao 'Nervous Text`
a.) Descripción
Esta applet muestra una línea de texto en la que las letras, aleatoriamente, se están
desplazando de tal forma que se superponen con las letras contiguas.
Es algo muy sencillo pero, por otra parte, muy llamativo.
b.) Parámetros
Œ text: El texto (sólo una línea) que se mostrará en la applet.
c.) Ejemplo
<applet code=”NervousText.class” width=200 height=50>
<param name=text value=”hello World!”>
</applet>
d.) Notas
Se necesitará establecer bien la anchura de la applet para que quepa toda la línea.
Puede servir para una firma en los mensajes de correo electrónico o de noticias, pero no
podrá verse si el navegador no soporta Java.
E. FINANCIAS Y NEGOCIOS: "BAR CHART"
Imagen 17. Applet ae financias v negocios 'Bar Chart`
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 154 de 189
a.) Descripción
Esta applet muestra un gráfico de barras basado en los parámetros que recibe.
b.) Parámetros
Œ title: Título del gráfico. Aparecerá debajo de las gráficas.
Œ colums: Número de columnas (barras) en el gráfico.
Œ orientation: Posición de las barras: horizontales o verticales.
Œ scale: Escala de representación (en pixels por unidad de barra).
Œ c·N~stvle: Textura de las barras: lisas o rayadas.
Œ c·N~value: Unidades de medida: dólares, días...
Œ c·N~label: Etiqueta de la barra: dinero, tiempo...
Œ c·N~color: Color de la barra: verde, azul, rosa, naranja, magenta ,amarillo...
c.) Ejemplo
<applet code=”Chart.class width=251 height=125>
<param name=title value=”Performance”>
<param name=columns value=”4”>
<param name=orientation value=”horizontal”>
<param name=scale value=”5”>
<param name=c1_style value=”striped”>
<param name=c1 value=”10”>
<param name=c1_color value=”blue”>
<param name=c1_label value=”Q1”>
<param name=c2_color value=”green”>
<param name=c2_label value=”Q2”>
<param name=c2 value=”20”>
<param name=c2_style value=”solid”>
<param name=c3 value=”5”>
<param name=c3_style value=”striped”>
<param name=c3_color value=”magenta”>
<param name=c3_label value=”Q3”>
<param name=c4 value=”30”>
<param name=c4_color value=”yellow”>
<param name=c4_label value=”Q4”>
<param name=c4_style value=”solid”>
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 155 de 189
d.) Notas
Si se modifica la orientación (poniéndola en vertical) habrá que escoger una anchura y
altura adecuadas para que todo el gráfico quepa dentro de la zona reservada para la
applet.
El usuario no puede interactuar con el gráfico. Sólo se muestra en pantalla.
F. JUEGOS Y EDUCACIONALES: "GRAPH LAYOUT"
Imagen 18. Applet ae iuegos v eaucacionales 'Graph Lavout`
a.) Descripción
Es una applet que despliega un grafo, consistente en un conjunto de nodos y arcos.
Se pueden definir los nodos que se van a usar así como la longitud óptima de los arcos.
El grafo está construido mediante un algoritmo heurístico.
b.) Parámetros
Œ center: Nodo central del grafo (en color rojo) que se sitúa en el centro de la pantalla.
ΠLos nodos se crean cuando se necesitan.
Œ eages: Arcos del grafo. Este parámetro consiste en una lista (separada por comas),
de arcos. Cada arco se define mediante un par de nodos entre las etiquetas origen-
aestino/longitua, donde la longitud del arco (longitua) es opcional.
c.) Ejemplo
<applet code="Graph.class" width=400 height=400>
<param name=edges value="joe-food, joe-dog, joe-tea,
joe-cat, joe-table, table-plate/50, plate-food/30,
food-mouse/100, food-dog/100, mouse-cat/150, tab1e-cup/30,
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 156 de 189
cup-tea/30, dog-cat/80, cup-spoon/50, plate-fork,
dog-fleal, dog-f1ea2, f1ea1-f1ea2/20, p1ate-knive”>
<param name=center value="joe">
</applet>
d.) Notas
El usuario puede recoger nodos y distorsionar el grafo para acelerar el proceso del
esquema.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 157 de 189
APÉNDICES
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 158 de 189
APÉNDICE I. EL JDK (Java Development Kit)
A. INTRODUCCIÓN
JDK es el acrónimo de "Java Development Kit", es decir Kit de desarrollo de Java. Se
puede definir como un conjunto de herramientas, utilidades, documentación y ejemplos
para desarrollar aplicaciones Java.
Para la realización de este tutorial se ha trabajado con la versión 1.2.0 del JDK.
B. COMPONENTES DEL JDK
a.) Introducción
JDK consta de una serie de aplicaciones y componentes, para realizar cada una de las
tareas de las que es capaz de encargarse
A continuación se explican más en profundidad cada uno de ellos, así como su sintaxis,
indicando entre corchetes aquellos elementos que sean opcionales.
Se observará que todos los programas permiten la inclusión de una serie de opciones
sobre su ejecución antes del primer argumento. Estas opciones se indican precedidas de
un menos(-):
programa -opcion1 -opcion2 Parametro1
Todas las opciones que los ejecutables del JDK presentan se muestran llamando al
programa sin parámetros o con las opciones -? o -help:
programa
programa -help
programa -?
b.) Intérprete en tiempo de ejecución (JRE)
Permite la ejecución de los programas Java (*.class) no gráficos (aplicaciones).
La sintaxis para su utilización es la siguiente:
java [Opciones] ClaseAEjecutar [Argumentos]
Œ Opciones: Especifica opciones relacionadas con la forma en que el intérprete Java
ejecuta el programa.
Œ ClaseAEiecutar: Especifica el nombre de la clase cuyo método main() se desea
ejecutar como programa. Si la clase reside en un paquete se deberá especificar su
ruta mediante en forma paquete.subpaquete.claseaeiecutar.
Œ Argumentos: Especifica los argumentos que se recibirán en el parámetro s del
método main(String s), por si el programa necesita de parámetros de ejecución. Si
por ejemplo el programa realiza el filtrado de un archivo, probablemente nos
interese recibir como argumento la ruta del fichero a filtrar, y una ruta destino.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 159 de 189
c). Compilador
Se utiliza para compilar archivos de código fuente Java (habitualmente *.java), en
archivos de clases Java ejecutables (*.class). Se crea un archivo de clase para cada clase
definida en un archivo fuente.
Este compilador es una utilidad en línea de comandos con la siguiente sintaxis:
javac [Opciones] ArchivoACompilar
Œ Opciones: Especifica opciones de cómo el compilador ha de crear las clases
ejecutables.
ΠArchivoACompilar: Especifica la ruta del archivo fuente a compilar, normalmente
una fichero con extensión ".iava".
d.) Visualizador de applets
Es una herramienta que sirve como campo de pruebas de applets, visualizando cómo se
mostrarían en un navegador, en lugar de tener que esperar.
Al ser activado desde una línea de órdenes abre una ventana en la que muestra el
contenido de la applet.
Se activa con la sintaxis:
appletviewer [Opciones] Applet
Œ Opciones: Especifica cómo ejecutar la applet Java.
Œ Applet: Indica un URL o una ruta de disco que contiene una página HTML con una
applet Java empotrada.
e.) Depurador
Es una utilidad de línea de comandos que permite depurar aplicaciones Java.
No es un entorno de características visuales, pero permite encontrar y eliminar los
errores de los programas Java con mucha exactitud. Es parecido en su funcionamiento al
depurador gab que se incluye con las distribuciones del compilador gcc/g¹¹ para
C/C++.
Se activa con la sintaxis:
jdb [Opciones]
Œ Opciones: Se utiliza para especificar ajustes diferentes dentro de una sesión de
depuración.
f.) Desensamblador de archivo de clase
Se utiliza para desensamblar un archivo de clase. Su salida por defecto, muestra los
atributos y métodos públicos de la clase desensamblada, pero con la opción -c también
desensambla los códigos de byte, mostrándolos por pantalla. Es útil cuando no se tiene
el código fuente de una clase de la que se quisiera saber cómo fue codificada.
La sintaxis es la siguiente:
javap [Opciones] [NombresClases]
ΠOpciones: Especifica la forma en la que se han de desensamblar las clases.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 160 de 189
ΠNombresClase: Especifica la ruta de las clases a desensamblar, separadas por
espacios.
g.) Generador de cabecera y archivo de apéndice
Se utiliza para generar archivos fuentes y cabeceras C para implementar métodos Java
en C (coaigo nativo). Esto se consigue mediante la generación de una estructura C cuya
distribución coincide con la de la correspondiente clase Java.
El generador de cabeceras iavah, crea los ficheros de cabecera C/C++ para implementar
en esos lenguajes los métodos nativos que presente un programa Java.
La sintaxis es la siguiente:
javah [Opciones] NombreClase
Œ NombreClase: Nombre de la clase desde la cuál se van a generar archivos fuente C.
Œ Opciones: Forma en la que se generarán los archivos fuente
h.) Generador de documentación
Es una herramienta útil para la generación de documentación API directamente desde el
código fuente Java. Genera páginas HTML basadas en las declaraciones y comentarios
iavaaoc, con el formato /'' comentarios '/:
/** Comentarios sobre la clase
@autor: Ignacio Cruzado
*/
class MiClase {
};
La documentación que genera es del mismo estilo que la documentación que se obtiene
con el JDK.
Las etiquetas, que se indican con una arroba ((), aparecerán resaltadas en la
documentación generada.
Su sintaxis es:
javadoc Opciones NombreArchivo
Œ Opciones: Opciones sobre qué documentación ha de ser generada.
Œ NombreArchivo: Paquete o archivo de código fuente Java, del que generar
documentación.
i.) Applets de demostración
El JDK incluye una serie de applets de demostración, con su código fuente al completo.
j.) Código fuente de la API
El código fuente de la API se instala de forma automática, cuando se descomprime el
JDK, aunque permanece en formato comprimido en un archivo llamado "scr.zip"
localizado en el directorio Java que se creó durante la instalación.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 161 de 189
C. USO DEL JDK
Ya se han visto las diferentes partes de que está compuesto el JDK, pero para el
desarrollo de una aplicación final Java (ya sea una aplicación o una applet), deberemos
utilizar las diferentes herramientas que nos proporciona el JDK en un orden
determinado.
En el siguiente diagrama podemos ver la sucesión de pasos para generar un programa
final Java:
Imagen 19. Utilizacion ael JDK
Edición del fuente:
Editor de Textos
(edit, vi, notepad)
Compilación:
javac MiClase
Codigo Fuente Java
MiClase.java
Codebyte Java:
MiClase.class
Documentación HTML
sobre MiClase
Ficheros de cabecera
C/C++
fichero.h
Documentación
automática:
javadoc
Inserción de métodos
nativos:
javah
Ejecución del
programa:
java MiClase
Ejecución del applet:
appletviewer MiClase
Editor de Textos
(edit, vi, notepad)
Salida del
programa
Página Web con applet
incrustado:
Pagina.html
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 162 de 189
D. OBTENCIÓN E INSTALACIÓN DEL JDK
El JDK se puede obtener de las páginas de Sun (http.//iava.sun.com), y existen
versiones disponibles para varias plataformas entre las que se encuentran:
ΠMicrosoft Windows 95 y NT 4.0
ΠSun Solaris 2.4 SPARC o 2.5 al 2.6 sobre x86 o SPARC.
ΠIBM AIX, OS/400 y OS/390
ΠLinux
Si su sistema operativo no ha sido enumerado, por favor consulte a su fabricante, pues
Sun tiene previsto desarrollar su JDK para más plataformas.
La instalación es diferente para cada sistema operativo, pero en general muy sencilla. Se
recomienda observar y establecer los valores de las variables de entorno:
Œ PATH: Variable de entorno que indica desde qué ruta (además del directorio actual)
se pueden ejecutar los programas
Œ CLASSPATH: Indica al compilador Java en qué rutas se encuentran los ficheros de
clase.
E. NOVEDADES EN LA VERSIÓN 1.2 DEL JDK (JAVA 2)
La aparición de la versión 1.2 del JDK (diciembre de 1997) significa un salto
importante en las capacidades de Java, hasta tal punto que comercialmente se conoce a
esta evolución como "Java 2".
a.) Clases
Se amplía el paquete de clases de JFC(Java Foundation Classes) pasando de 23 a 70
clases. Aparecen nuevos paquetes de la API Java:
Œ Swing: Nuevo paquete de gráficos.
Œ Java 2D: Ampliación de AWT.
Œ Java Collections: Incluye nuevas clases que representan estructuras de datos clásicas
de la programación: Jector. ArravList. ArravSet. TreeMap...
b.) Eficiente ejecución
Œ Compatible con programas realizados en otras versiones, tanto en código como en
ejecución.
Œ Compilador más estricto y que genera un código más optimizado.
Œ Entorno de ejecución más rápido y estable (máquina virtual), próximo a la velocidad
de ejecución de C++, especialmente utilizando los nuevos compiladores Just In
Time (JIT), incorporados en las nuevas JRE, que compilan las clases para las
plataformas locales, aumentando su velocidad de ejecución.
Œ Mejora en la gestión de la seguridad: Control de acceso basado en el plan de acción,
soporte para certificados X509v3 y nuevas herramientas y certificados de seguridad.
ΠMejor tratamiento de sonido.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 163 de 189
Œ Más velocidad de las clases que utilizan RMI.
ΠY por supuesto se solventan errores de versiones pasadas.
c.) JavaBeans
ΠJava Plug-in: Permite que las applets y los JavaBeans de una red utilicen el JRE 1.2,
en vez de la máquina virtual del navegador en que se muestren.
ΠSe permite a los JavaBeans interactuar con applets y se les da un mejor soporte en
tiempo de diseño y en tiempo de ejecución.
ΠLos JavaBeans se pueden incluir unos en otros.
d.) Otros
ΠIDL (Interface Definition Language): Para interactuar con CORBA de una forma
simple y práctica se utiliza Java.
ΠJCE (Java Criptographv Extensions): Se ofrecen mejores posibilidades para el
tratamiento seguro de la información.
ΠRMI (Remote Methoa Invocation): Permite realizar acciones sobre objetos remotos,
incluso mediante SSL (Security Socket Layer) un conocido sistema de seguridad de
comunicación.
Œ Tecnología de ayuda.
ΠMejor soporte de arrastrar v soltar.
ΠOtros servicios varios.
e.) Observaciones
Aunque no existen incompatibilidades importantes, sí que se pueden observar que
algunas cosas que en otras versiones no funcionaban bien o se permitían ahora se
desaprueban. Entre otros conviene destacar:
Œ No se pueden declarar métodos abstractos como native, private, final ni svncronzea.
Œ No se recomienda la utilización de finalize{} en la gestión de excepciones.
Œ El paquete Swing en algunas versiones intermedias aparecía colgando de
com.sun.iava.' o de iava.awt.swing.' y ahora pasa a ser iavax.swing.'.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 164 de 189
APÉNDICE II: HERRAMIENTAS DE DESARROLLO
A. PROGRAMAS DE NAVEGACIÓN
a.) Introducción
Las applets Java no serían de mucha utilidad sin programas de navegación compatibles
con Java. Por lo tanto, para que Java funcione necesita de estos programas de
navegación, que afortunadamente se han comprometido a apoyarlo.
b.) Netscape Navigator
Es un programa de navegación con apoyo completo a Java. Además del simple apoyo al
lenguaje y sistema de tiempo de ejecución, también ha ayudado en el desarrollo de
JavaScript, que es un lenguaje de comandos basado en objetos Java. El objetivo de
JavaScript es permitir el desarrollo rápido de aplicaciones distribuidas cliente servidor.
Para más información consultar http://home.es.netscape.com/
c.) Microsoft Internet Explorer
Microsoft tardó un poco en desarrollar una herramienta para Java: Internet Explorer.
Está estrechamente ligado al sistema operativo Microsoft Windows 95, y está
completamente integrado en la versión Windows 98 del mismo.
Para más información consultar http://www.microsoft.com/
d.) HotJava
Es el contendiente de Sun. Se diseñó inicialmente como un experimento en el desarrollo
del programa de navegación de Java. Se ha convertido en un prometedor modelo de lo
que depara el futuro para los programas de navegación de la Web. Será el programa de
navegación existente más compatible con Java. Constituye un útil campo de pruebas
para los programadores de Java.
Es capaz de gestionar e interactuar de forma dinámica con nuevos tipos de objeto y
protocolos Internet.
Para más información consultar http://www.sun.com/
e.) Spyglass Mosaic
Fue el primer navegador de Internet, y ya está disponible con apoyo a Java.
Para más información consultar http://www.spyglass.com/
B. ENTORNOS DE DESARROLLO
a.) Introducción
Los desarrolladores se han acostumbrado a las herramientas gráficas de programación, y
aunque el JDK es suficiente para desarrollar Java, se han creado muchos entornos de
desarrollo (IDEs) para este lenguaje.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 165 de 189
La mayor parte de los participantes en el negocio de herramientas de programación han
anunciado algún tipo de entorno de desarrollo para Java. Parte de ese apoyo ha llegado
en forma de módulos adicionales para productos ya existentes, mientras que otra parte
consistirá en productos totalmente nuevos.
En este apartado se comentan algunos de los más valorados, y se indican otros por si el
lector desea buscar algo con unas características muy específicas.
b.) Visual Café de Symantec
La empresa Symantec, dura competidora en los IDE de Java ofrece el entorno visual de
desarrollo Java Visual Café, que ya goza de una gran reputación entre los
desarrolladores de Java.
Integra de forma transparente las herramientas del JDK, presentándolas en formato
gráfico.
Las principales funciones que soporta son las siguientes:
Œ Editor de programación gráfica: Posee todas las características de un moderno editor
de programación: sintaxis a todo color, resaltado de palabras clave, lenguaje macro
integrado para ampliar el editor...
Œ Editor de clases y jerarquías: Navega con rapidez a través del código Java,
permitiendo trabajar directamente con clases o miembros de clases en lugar de
archivos individuales; este editor localiza el código fuente correspondiente y lo
carga. Además gestiona y visualiza las relaciones lógicas entre clases.
Œ Depurador gráfico: Gran ventaja sobre el iab que es modo línea.
ΠGestor de proyectos: Permite organizar proyectos Java con mayor efectividad.
Soporta proyectos dentro de proyectos, por lo que puede mantenerse al día con
bibliotecas anidadas y dependencias de proyectos.
Œ Asistentes: Para creación de eventos, bases de datos, applets...
Para más información, consultar http://cafe.symantec.com/
c.) Visual J++ de Microsoft
Es la nueva herramienta de Microsoft para desarrollar Java en sus sistemas operativos
Microsoft Windows. Se encuentra incluido en el paquete de desarrollo Microsoft Jisual
Stuaio, y es directo heredero del tan extendido Microsoft Jisual C¹¹.
Presenta el serio problema de que no respeta las especificaciones de clases de Sun, lo
que ha llevado a ambas compañías a juicio; en lugar de utilizar las clases del JFC,
Microsoft se ha inventado un nuevo paquete WFC(Windows Foundation Classes), para
el desarrollo en la plataforma Windows, rompiendo la portabilidad.
Para más información consultar http://www.microsoft.com/
d.) JBuilder de Borland
La empresa Borlana es la desarrolladora de populares entornos de desarrollo de C++ y
Delphi para Windows. Borland ha optado por desarrollar un producto totalmente nuevo
para los desarrolladores de Java; JBuilaer.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 166 de 189
JBuilaer ha sido desarrollado totalmente en Java, lo que permite a Borland salir del
mercado del PC y comercializar JBuilaer en todas las plataformas soportadas por Java.
Presenta gran conectividad con las bases de datos, soportando incluso CORBA. Tiene
un programa de desarrollo de JavaBeans con más de 200 prediseñados.
Realmente es un producto muy completo de desarrollo de Java, y se distribuye en dos
versiones (standard y Cliente/Servidor).
Para más información, consúltese http://www.borland.com/jbuilder/
e.) Java Studio de Sun
Entorno muy intuitivo y práctico, en el que casi la mayoría de las tareas se realizan
mediante el ratón. Es muy fácil crear aplicaciones sencillas con este IDE, pero se
necesita tener una versión del JDK previamente, y tiene unos requisitos hardware
bastante altos.
Para más información consúltese http://www.sun.com/
f.) VisualAge for Java de IBM
Es una RAD (Rapia Aiaaea Design), que aunque tiene muchas de las características del
Visual Café, con una interfaz un poco más limpia. Permite diseñar la interfaz de la
aplicación o applet, y definiendo el sistema de eventos, la herramienta puede crear
código Java.
Es muy sencillo de manejar y uno de los más potentes del mercado.
Para más información, consúltese http://www.ibm.com/ad/vajava/
g.) Y muchos más...
Los IDE están en continuo desarrollo, y seguro que tras la finalización de este tutorial
ya han aparecido muchos más en el mercado.
Algunos de ellos son:
ΠCodeWarrior de Metrowerks: Entorno de desarrollo Java para Macintosh, basado en
Coaewarrior C¹¹. http://www.metrowerks.com/
ΠRoaster de Natural Intelligence: Entorno de desarrollo Java para Power Macintosh.
http://www.natural.com/page/products/roaster/
ΠCosmo de Silicon Graphics: Conjunto de herramientas de desarrollo Cosmo con dos
bibliotecas propias. http://www.sgi.com/products/cosmo/
ΠSuperCede de Asvmetrix: Un producto a bajo precio, con algunos tutoriales.
http://www.asymetrix.com/sales/
Π1ava Maker: Sencillo entorno de desarrollo que funciona bajo Windows 95/NT,
creado por Heechang Choi. http://net.info.samsung.com.kr/~hcchoi/Javamaker.html
ΠEd de Soft As It Gets: Editor muy potente para Windows, aunque flojo en otros
aspectos. http://www.ozwmail.com.au/~saig
Œ Moio de Penumbra Software: Entorno visual para crear applets, fácil de usar.
http://www.PenumbraSoftware.com
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 167 de 189
Œ 1amba de Aim1ech: Constructor gráfico de applets, con mucha documentación.
http://www.aimtech.com/prodjahome.html
La información de este apartado ha sido extraída de }Rojo, 1998], }Morgan, 1999] y
}Zolli, 1997].
Se recomienda al lector que busque en Internet en las direcciones:
Πhttp://www.developer.com/news/userchice/n_userframe.html: Lista de los entornos
de desarrollo preferidos por los desarrolladores de Java.
Πhttp://www.yahoo.com/Business_and_Economy/Companies/Computes/Software/PR
ogramming_Tools/Languages/Java: Lista de últimas herramientas Java.
C. BIBLIOTECAS DE PROGRAMACIÓN
Java está orientado a objetos, por lo que es importante no ignorar el potencial de volver
a utilizar objetos Java. De hecho ya están apareciendo algunas bibliotecas comerciales
de objetos Java.
Œ Por ejemplo, la empresa Dimensión X cuenta con tres bibliotecas de clases Java:
Œ Ice: Paquete de representación de gráficos tridimensionales.
ΠLiquid Reality: Kit de herramientas VRML.
Œ JACK: Herramienta para crear applets Java a través de una interfaz sencilla.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 168 de 189
APÉNDICE III: MÉTODOS NATIVOS JAVA (JNI)
A. INTRODUCCIÓN
Aunque la potencia de la API de Java es más que suficiente para casi todo tipo de
aplicaciones, algunas de ellas necesitan utilizar la potencia específica de una plataforma
en concreto, por ejemplo para conseguir un poco más de velocidad y eficiencia.
Java permite incorporar en sus programas fragmentos de coaigo nativo es decir, código
compilado para una determinada plataforma, generalmente escrito en C/C++. Así se
puede utilizar código específico de una plataforma, bibliotecas ya escritas...
Para ello Java cuenta con el JNI (Java Native Invocation). Hay que tener en cuenta que
una aplicación que utilice este tipo de métodos estará violando las directrices de
seguridad de la máquina virtual Java, motivo por el que no se permite incluir métodos
nativos en applets de Java.
Para agregar métodos nativos Java a una clase de Java han de seguirse los siguiente
pasos:
1. Escritura del programa Java, invocando métodos nativos como native.
2. Compilación del programa Java.
3. Creación de un archivo de cabecera nativo (.h)
4. Escritura de los métodos nativos.
5. Creación de una biblioteca con esos métodos nativos.
6. Ejecución del programa Java.
B. EJEMPLO DE USO DE MÉTODOS NATIVOS
Para mostrar cómo utilizar los métodos nativos, vamos a crear un pequeño programa,
escrito con métodos nativos, que lo único que hace es imprimir "¡Hola Munao'''". Para
ello vamos a utilizar el JDK y un compilador de C.
Se advierte al lector que no se deje engañar por la simpleza del ejemplo que se va a
desarrollar, porque la potencia del JNI va mucho más allá de lo que estas líneas dejan
entrever. Para más información consulte }Morgan, 1999].
a.) Escritura del programa Java
Escribimos el programa Java en un fichero denominado HolaNativo.iava.
El código Java que vamos a utilizar será:
puclic class HolaNativo{
public native void diHola();
static {
System.loadLibrary("LibHola");
}
public static void main( String[] args ) {
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 169 de 189
new HolaNativo().diHola();
}
}
El método nativo aiHola() no tiene cuerpo porque será añadido mediante una biblioteca
nativa denominada LibHola. Dicha biblioteca nativa es cargada mediante la sentencia
loaaLibrarv(), sentencia que ha sido incluida como static para que sea ejecutada cada
vez que se cree una instancia (objeto) de esta clase.
El programa principal tan sólo instancia un objeto de esta clase y utiliza el método
nativo que imprime la cadena de "¡Hola Munao'''".
b.) Compilación del programa Java
Ahora ya es posible compilar la clase Java HolaNativo que fue creada mediante la
sentencia (utilizando el JDK):
javac HolaNativo.java
c.) Creación de un fichero de cabecera nativo (.h)
Un fichero de cabecera nativo es un fichero que habitualmente tiene la extensión ".h".
En un fichero de este tipo se definen en C/C++ las interfaces públicas (clases, métodos
o funciones, variables globales, constantes...).
La herramienta iavah incluida en el JDK es capaz de crear automáticamente un fichero
de cabecera para métodos nativos Java, con sólo invocarla indicando el nombre de la
clase de la que extraer las cabeceras nativas:
javah HolaNativo
Esta operación crea un fichero HolaNativo.h que será útil para crear los métodos
nativos. Hay dos líneas importantes dentro de este fichero:
#include <jni.h>
JNIEXPORT void JNICALL Java_HolaNativo_diHola(JNIEnv*,jobject);
La primera línea importa una biblioteca JNI que valdrá a C/C++ para saber cómo crear
los métodos nativos.
La segunda línea corresponde al método nativo que definimos.
Los métodos nativos suelen denominarse siempre como Java_Paquete_Clase_Metodo()
aunque en este caso al no haber paquete esta parte se ha omitido.
Así mismo los métodos nativos reciben como parámetros JNIEnv' y iobiect que
permitirán al método nativo comunicarse con su entorno.
d.) Escritura de los métodos nativos
Se ha de crear un fichero fuente nativo, en el que se defina el cuerpo de la función que
actuará como método nativo. Este fichero lo denominaremos HolaNativo.c:
#include <jni.h>
#include "HolaNativo.h"
#include <stdio.h>
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 170 de 189
JNIEXPORT void JNICALL Java_HolaNativo_DiHola( JNIEnv* e,
jobject o ){
printf("¡Hola Mundo!!!\n");
}
En este programa se incluyen tres bibliotecas: La de JNI (ini.h), el fichero de cabecera
ya creado (HolaNativo.h) y una biblioteca de C para imprimir (staio.h).
Ser puede observar que el cuerpo del método nativo lo que hace es invocar a la función
de C printf() que imprimirá por pantalla la cadena "¡Hola Munao'''".
e.) Creación de una biblioteca con esos métodos nativos
Cada compilador de C o C++ tiene su propia herramienta para crear bibliotecas
compartidas (DLL en Windows o SO en UNIX).
Para crear la biblioteca se ha de compilar el fichero fuente nativo, y luego crear la
biblioteca compartida mediante el programa correspondiente a su compilador.
Para esto cada compilador tiene su propia sintaxis, con lo que se tendrá que consultar la
documentación del compilador en lo referente a la creación de bibliotecas. En cualquier
caso algunos ejemplos de compilación en bibliotecas son:
Para el GCC de Solaris:
cc -G HolaNativo.c -o libHola.so
Para Microsoft Visual C++ para Windows:
cl -LD HolaNativo.c -Fe libHola.dll
En cualquier caso asegúrese que la biblioteca creada tiene el mismo nombre con que se
la invoca desde el archivo de clase Java en el método loaaLibrarv().
f.) Ejecución del programa Java
Para ejecutar este programa, debe invocarse:
java HolaNativo
Con lo que se muestra por pantalla:
Hola Mundo
Se puede observar que la forma de creación, compilación y ejecución de la clase Java es
igual que la utilizada para crear una aplicación Java normal, solo que al incluir métodos
nativos, han de crearse bibliotecas y ficheros de cabecera antes de ejecutar el programa.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 171 de 189
APÉNDICE IV: GUÍA DE REFERENCIA DE C++ A JAVA
A. INTRODUCCIÓN
La sintaxis de Java resulta muy familiar a los programadores de C++, debido
mayoritariamente a que Java proviene de C++. Sin embargo Java pretende mejorar a
C++ en muchos aspectos (sobre todo en los aspectos orientados a objeto del lenguaje),
aunque prohibe muchas de las tareas por las que C++ fue tan extendido.
Se observa que las diferencias han sido diseñadas como mejoras del lenguaje, ya que
uno de los aspectos más criticado (y defendido) de C++ es su capacidad para hacer
cosas “no orientadas a objetos”, así como acceder a los recursos de las máquinas (lo que
le permitía atacar sistemas, siendo uno de los lenguajes más difundidos entre los
programadores de virus).
En este apéndice pretendemos mostrar aquellas diferencias significativas, para que los
programadores familiarizados con C++ puedan programar en Java, conociendo sus
posibilidades y limitaciones.
B. DIFERENCIAS SINTÁTICAS
a.) Elementos similares
Uso de bibliotecas (paquetes): Como no existen macros como rincluae, se utiliza
import.
Operador de herencia: La herencia en Java se especifica con la palabra clave extenas,
en lugar del operador :: de C++.
Constantes: En lugar de const de C++ las variables constantes se declaran como static
final.
b.) Elementos equivalentes
Miembros estáticos: No es necesaria declaración previa (fuera de las clases) de los
miembros estáticos (static).
Métodos inline: En Java no existen (hay que incluir el cuerpo de los métodos junto a su
definición), aunque los compiladores Java suelen intentar expandir en línea (a modo de
los métodos inline) los métodos declarados como final.
Métodos virtuales: Todos los métodos no estáticos (static) se consideran virtual en
Java.
Forward: No existe en Java. Simplemente se llama el método, y el compilador se
encarga de buscarlo.
Clases anidadas: Aunque Java no permite anidar clases, sí que se puede modelizar este
concepto mediante los paquetes Java y la composición.
No existen "amigos" (friend): Es su lugar se considera amigas a todas las clases y
elementos que componen un paquete.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 172 de 189
c.) Elementos añadidos
Comentarios: Java soporta los dos tipos de comentarios de C++, e incorpora un tercero,
con la sintaxis /'' comentario '/, para la documentación automática.
Operador >>> : Java añade este operador para desplazamientos a la derecha con signo.
Iniciación: Todos las variables de tipo simple y las referencias a objeto se inician a un
valor 0 (o equivalente), y null para las referencias a objeto.
Referencia super: En Java super hace referencia a la superclase (clase padre) de la
clase actual. Dicha clase sólo puede ser una, porque Java solo soporta herencia simple.
d.) Elementos suprimidos
goto: No existe en Java, aunque con break y continue, combinados con etiquetas de
bloque, se puede suplir.
Condiciones: Deben utilizarse expresiones booleanas y nunca números.
Argumentos por defecto: Java no los soporta.
C. DIFERENCIAS DE DISEÑO
a.) Tipos de datos
Tipos simples: Soporta los mismos que C++, añadiendo boolean (true/false), y
ampliando el tipo char, para soportar caracteres Unicode de 16 bits.
Punteros: En Java no hay punteros, permitiendo así programación segura. En su lugar
se crean las referencias a objeto, que pueden ser reasignadas (como si fueran un puntero
a objeto de C++).
Vectores: Son objetos de sólo lectura, con un método length() para averiguar su
longitud, y que lanzan una excepción si se intenta acceder a un elemento fuera del
vector.
Clases: Todo debe de estar incluído en clases; no existen enumeraciones (enum) ni
registros (struct).
Elementos globales: No existen variables o funciones globales, aunque se puede
utilizar static para simularlas.
b.) Diseño de las clases
Cuerpo de los métodos: Todos los cuerpos de las clases han de estar codificados en las
definiciones de las clases. No se pueden separa como se hace en C++ mediante ficheros
de cabecera (".h").
Constructores: Aunque existen constructores, como en C++, no existen constructores
copia, puesto que los argumentos son pasados por referencia.
Destructores: No existen destructores en Java, ya que tiene recolección automática de
basura, aunque en su lugar se pueden escribir métodos finalize(), que serán ejecutados
cuando el recolector de basura de Java destruya el objeto.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 173 de 189
Árbol de herencia: En Java todas las clases se relacionan en un único árbol de
herencia, en cuya cúspide se encuentra la clase Obiect, con lo que todas las clases
heredan de ella. En C++ sin embargo se pueden declarar clases que no tengan padre.
Herencia no restrictiva: Al heredar, no se puede reducir las ocultaciones del padre: En
C++ sí se podría ampliar la visibilidad de uno de los elementos heredados. En todo caso
sí se puede restringir.
Herencia simple de clases: No existe la herencia múltiple de clases. Aún así se puede
implementar una herencia múltiple utilizando interfaces, dado que ellas sí la soportan.
Sobrecarga de métodos: Es exactamente igual que la de C++.
Sobrecarga de operadores: No existe. En los objetos String el operador + y += se
permiten para la comparación de cadenas.
c.) Nuevos diseños
Plantillas (templates): En Java no se soportan plantillas p clases genéricas de C++,
aunque existen una serie de clases en la API de Java que tratan objetos genéricos (clase
Obiect) como Jector o Stack.
Interfaces (interface): Que son unas especies de clases abstractas con metoaos
abstractos, y que permiten herencia múltiple, utilizando la palabra reservada
implements.
Diferente gestión de excepciones: Todas las excepciones de Java heredan de la clase
Throwable, que las dota de una interfaz común.
D. DIFERENCIAS DE EJECUCIÓN
a.) Aspectos modificados:
Cadenas: Las cadenas entrecomilladas se convierten en objetos String, no en vectores
estáticos de caracteres.
Instanciación: Los objetos se crean en el montículo (new) y nunca en la pila (malloc), y
los tipos simples no permiten new (excepto los vectores de tipos simples, iguales que los
de C++).
Intérprete: Los intérpretes Java son unas 20 veces más lentos que los de C, aunque esta
diferencia se está reduciendo con lo compiladores JIT(Just In Time) para Java que están
apareciendo en el mercado.
Bibliotecas estándar: En C++ existía casi una biblioteca por plataforma (si existía)
para hacer cosas como: Trabajo en red, conexión a bases de datos, uso de múltiples
hilos de control, uso de objetos distribuídos o compresión. Java incorpora bibliotecas
estándar multiplataforma para todas estas tareas en su API.
Excepciones por fallos de descriptores: Java lanza excepciones cuando hay errores en
el acceso a un descriptor, permitiendo al programador gestionar dichos fallos, y
recuperar al programa de ellos.
Gestión de errores al compilar: Además comprobar el lanzamiento de excepciones en
tiempo de compilación, comprueba el cumplimiento del lanzamiento de excepciones por
los métodos sobreescritos.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 174 de 189
b.) Aspectos eliminados:
Preprocesador: Java no tiene preprocesador, por lo que las macros (rincluae.
raefine....) no existen.
Acceso directo al hardware: En Java está restringido, aunque para eso permite la
utilización de metoaos nativos, escritos para la plataforma (normalmente C/C++). En
cualquier caso las applets no pueden utilizar estos metoaos nativos, sólo las aplicaciones
Java pueden hacerlo.
c.) Aspectos introducidos
Multiples hilos de control (multithreating): Java permite la utilización de múltiples
hilos de control y la ejecución en paralelo (y sincronizada) de múltiples tareas, mediante
la clase Threaa.
Applets 1ava: Este tipo de aplicaciones son seguras, distribuíbles por Internet y
ejecutables por los navegadores, aunque tienen restricciones (como la escritura en
disco).
Extracción automática de documentación: Un nuevo tipo de comentario
(/''comaoc'/) permite a los programadores extraer de manera automática comentarios
de sus fuentes, generando automáticamente documentación estandarizada.
1avaBeans: Mediante esta biblioteca se permite crear elementos visuales
multiplataforma, algo impensable en C++.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 175 de 189
APÉNDICE V: GUÍA DE REFERENCIA DEL LENGUAJE JAVA
A. FUNDAMENTOS
Palabras reservadas (funcionales):
abstact boolean break bvte case
catch char class continue aefault
ao aouble else extenas false
final finallv float for if
implements import instanceof int interface
long native new null package
private protectea public return short
static super switch svncronicea this
throw throws transient trv voia
volatile while
Tipos de comentarios:
/*comentario*/ // Hasta fin de línea //* javadoc */
Bloques de código:
{ // conjunto de sentencias
}
Separadores Java:
{ } , : ;
Propuestas de estilo de nombres de identificadores:
Las clases: Clase o MiClase.
Los métodos: metoao() o metoaoLargo().
Las variables: altura o alturaMeaia.
Las constantes: CONSTATE o CONSTANTELARGA.
Los paquetes: iava.paquete.subpaquete.
B. TIPOS DE DATOS
Tipo bytes Tipo Datos Rango (positivo) Literal
bvte 1 Entero 127 14
short 2 Entero 32767 14
int 4 Entero 2.147.483.647 14
long 8 Entero 9.233e15 14
float 4 Coma flotante 1.4e-45 a 3.4e38 36,6
aouble 8 Coma flotante 4.9e-324 a 1.7e308 3,14e2
char 2 Caracter Unicode ’a’ o \064
boolean 1 Booleano true o false true o false

Vectores:
int vectorNumeros[]=new int[numero];
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 176 de 189
Cadenas Constates:
String nombreBonito = ”Amelia”;
Cadenas Variables:
StringBuffer cadenaVariable = ”Cambiante”;
C. OPERADORES
Operadores Unarios:
Operador Descripción (prefija) Operador Descripción (pre o posfija)
+ Convierte el operador a int ++ Incrementa operador
- Niega aritméticamente oper. -- Decrementa operador
Operadores aritméticos (binarios):
Operador Uso Atajo Descripción
¹ op1 ¹ op2 op1 += op2 Suma op1 y op2
- op1 - op2 op1 -= op2 Resta op2 de op1
' op1 ' op2 op1 *= op2 Multiplica op1 por op2
/ op1 / op2 op1 /= op2 Divide op1 por op2
º op1 º op2 op1 %= op2 Resto de op1 / op2
Operadores de comparación (binarios):
Operador Uso Devuelve verdadero si
> op1 > op2 op1 es mayor que op2
>= op1 >= op2 op1 es mayor o igual que op2
< op1 < op2 op1 es menor que op2
<= op1 <= op2 op1 es menor o igual que op2
== op1 == op2 op1 y op2 son iguales
!= op1 != op2 op1 y op2 son distintos
&& op1 && op2 AND, condicionalmente evalúa op2
& op1 & op2 AND, siempre evalúa op1 y op2
[[ op1 [[ op2 OR, condicionalmente evalúa op2
[ op1 [ op2 OR, siempre evalúa op1 y op2
' ' op op es falso
Operadores de bit (binarios):
Operador Uso Operación
~~ op1 ~~ op2 Desplaza los bits de op1 a la derecha op2 veces
·· op1 ·· op2 Desplaza los bits de op1 a la izquierda op2 veces
~~~ op1 ~~~ op2 Desplaza los bits de op1 a la derecha op2 veces (sin signo)
& op1 & op2 AND
[ op1 [ op2 OR
´ op1 ´ op2 "XOR"
op2 Complemento
Operador terciario:
expresion ? sentencia_si : sentencia_si_no
Precedencia de operadores:
Tipo de operadores Operadores de este tipo
Operadores posfijos [ ] . (parametros) expr++ expr--
Operadores unarios ++expr --expr +expr -expr ~ !
Creación o conversión new (tipo) expr
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 177 de 189
Multiplicación * / %
Suma + -
Desplazamiento <<
Comparación < <= = instanceof
Igualdad == !=
AND a nivel de bit &
OR a nivel de bit ^
XOR a nivel de bit |
AND lógico &&
OR lógico ||
Condicional ? :
Asignación = += -= *= /= %= &= ^= |= <<= = =
D. ESTRUCTURAS DE CONTROL
Toma de decisión (if-else y switch):
if ( condición ) {
Bloque de código a ejecutar si la condición es cierta
}
else {
Bloque de código a ejecutar si no
}
switch ( expresionMultivalor ) {
case valor1 : conjuntoDeSentencias; break;
case valor2 : conjuntoDeSentencias; break;
case valor3 : conjuntoDeSentencias; break;
default : conjuntoDeSentencias; break;
}
Bucles iterativos (while, ao-while, for):
while ( expresiónBooleana ) {
sentencias;
};
do {
sentencias;
} while ( expresiónBooleana );
for(inicio; condicion_continuacion; sentencia_actualizacion) {
sentencias;
}
Sentencias de saltos:
etiquetaSentencia: sentenciaEtiquetada
break nombreEtiqueta; // Sale del último bucle
continue; // Hace otra pasada al último bucle
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 178 de 189
return valor; // Sale del método devolviendo valor
E. CLASES
Definición de clase:
acceso class NombreDeClase herencia{
acceso tipo nombreAtributo1;
NombreDeClase{ // Constructor
}
// . . .
finalize { //Recogida de basura
}
acceso tipo_devuelto nombreMétodo1( parámetros ) {
cuerpo_del_método1;
}
}
Tipos de acceso de las clases:
Πfinal: Sin subclases
Πabstract: Clase abstracta, luego no se permiten instancias de esta clase.
Πpublic: Accesible desde fuera de su paquete
Herencia:
Œ extenas: Clase padre. La clase Obiect es superclase de todas las clases Java (raíz del
árbol de herencia).
Πimplements: Interfaces padres, separadas por comas; Interface1. Interface2.
class MiClase extends SuPadre implements Interface0,Interface1;
F. ATRIBUTOS
Acceso (igual que para métodos):
Πpublic: Los miembros declarados public son accesibles en cualquier lugar en que sea
accesible la clase, y son heredados por las subclases.
Œ private: Los miembros declarados private son accesibles sólo en la propia clase.
Œ protectea: Los miembros declarados protectea son accesibles sólo para sus
subclases
Composición:
class claseCompuesta {
claseComponente referenciaAObjetoComponente.
}
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 179 de 189
G. MÉTODOS
Referencias válidas en los métodos:
Πthis: Referencia al objeto actual.
Œ super: Referencia a la clase padre en el árbol de herencia.
Modificadores permitidos:
ΠAcceso: public private o protectea. Igual que para los atributos.
Œ abstract: Método abstractos, sin cuerpo. Sólo se permiten en clases abstractas.
Œ final: No se puede sobreescribir el método.
Œ static: Método de la clase (no de los objetos).
Œ native: Método implementado con métodos nativos (específicos de una plataforma).
Œ svnchronizea: Solamente permite un hilo de ejecución.
Sobrecarga del método: Varias implementaciones en función de los parámetros.
Sobreescritura del método: Un cuerpo en cada nivel de herencia.
H. OBJETOS
Instanciación:
NombreDeClase referenciaAObjeto = new NombreDeClase();
Acceso al objeto:
referenciaAObjeto.método( parámetros );
referenciaAObjeto.atributo;
Destrucción: Cuando la referencia a objeto sale de ámbito en el programa.
I. INTERFACES
Declaración de una interfaz:
interface MiInterfaz {
int CONSTANTE = 100;
int metodoAbstracto( int p ); // Por definir
}
Implementación de interfaces:
class ImplementaInterfaz implements MiInterfaz{
int m=CONSTANTE;
int metodoAbstracto( int p ){ return ( p*m ); }
}
Herencia múltiple entre interfaces:
interface InterfazMultiple extends Interfaz0,Interfaz1;
Clases de envoltura de tipos simples:
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 180 de 189
Clases de envoltura de tipos simples
Double aouble
Float float
Integer int. short. bvte
Long long
Character char
Boolean boolean
J. PAQUETES
Creación de un paquete (primera sentencia de un fichero fuente):
package NombrePaquete;
Importación de un paquete o parte de él:
import Paquete.Subpaquete1.Subpaquete2.Clase1;
Paquete.Subpaquetes1.Subpaquete2.Clase_o_Interfaz.elemento
Visibilidad en los paquetes:
Situación del elemento private por defecto protected public
En la misma clase

Sí Sí Sí Sí
En una clase
en el mismo paquete
No Sí Sí Sí
En una clase hija
en otro paquete
No No Sí Sí
En una clase no hija
en otro paquete
No No No Sí
K. EXCEPCIONES
Tipos de excepciones:
ΠError: Excepciones que indican problemas muy graves, que suelen ser
irrecuperables y no deben casi nunca ser capturadas.
ΠException: Excepciones no definitivas, pero que se detectan fuera del tiempo de
ejecución.
Œ RuntimeException: Excepciones que se dan durante la ejecución del programa.
Lanzamiento de una excepción:
metodoLanzador() throws MiException{
throw MiException:
}
Tratamiento de una excepción:
try {
// Código posiblemente problematico
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 181 de 189
} catch( tipo_de_excepcion e) {
// Código para solucionar la excepcion e
} catch( tipo_de_excepcion_mas_general e)
// Código para solucionar la excepcion e
} finally {
// Se ejecutara tras try o catch
}
L. THREADS
Creación:
ΠPara crear un threaa, se ha de implementar una clase, extendiendo la clase base
Runnable, y crear un objeto de la clase Threaa.
Œ Este objeto representará un nuevo hilo de control, que será accionado cuando
invoquemos al método start() del threaa.
Œ En ese momento este hilo se activará, ejecutando (si el planificador de hilos
considera que es el momento), el método run() de la clase en que todo esto suceda.
Sincronización de procesos:
Œ Durante la ejecución de un programa, muchas veces varios procesos han de realizar
tareas de una forma sincronizada, actuando en un determinado orden.
Œ Para ello se han de declarar métodos como svncronizea.
Œ Mediante la utilización de excepciones, y de las funciones wait() y notifiv(),
respectivamente esperarán a que otro proceso acabe antes de continuar su ejecución.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 182 de 189
GLOSARIO
Abstract Windowing Toolkit (AWT).- Biblioteca de módulos pera representar
interfaces gráficos provisto por Sun en la API de Java.
Administrador de Seguridad.- Parte de la máquina virtual Java responsable de velar
por el cumplimiento de las políticas y reglas de seguridad.
Ámbito.- Parte de un programa en el que es válida una referencia a una variable.
American Standard Code for Information Interchange (ASCII).- Sistema de
codificación que convierte caracteres a números en el rango de 0 a 127. Es una parte del
código ANSI que se amplía hasta los 257 caracteres.
Análisis.- Proceso de conocer los requerimientos de software que tienen el cliente y el
usuario final.
API.- Application Programming Interface.
Aplicación.- Programa informático, que se ejecuta sin necesidad de otro programa
Applet.- Programa informático que se ejecuta necesitando de otro programa,
normalmente un navegador.
Application Programming Interface (API).- Conjunto de paquetes y clases Java,
incluidos en el JDK que utilizan los programadores Java para realizar sus aplicaciones.
Árbol.- Estructura de datos, grafo no cíclico, con forma de árbol (nodos padres e hijos).
Argumentos.- Parámetros.
Array.- Vector.
ASCII.- American Standard Code for Information Interchange.
AWT.- Abstract Windowing Toolkit.
BDK.- Beans Developer Kit.
Beans Developer Kit (BDK).- Conjunto de herramientas para desarrollar JavaBeans.
Bit.- Unidad mínima de información digital que puede tomar los valores lógicos de 0 o
de 1.
Bloque.- Código localizado entre corchetes.
Boolean.- Tipo de datos bi-estado, que puede tomar valor de cierto (true) o falso (false).
Byte.- Secuencia de 8 bits.
Cadena.- Secuencia de caracteres.
Carácter.- Símbolo que representa información, o la codificación en una computadora.
Normalmente letras de alfabeto, números o signos ASCII.
Cargador de clases.- Parte del JRE de Java responsable de encontrar archivos de clase
y cargarlos en la máquina virtual Java.
Casting.- Moldeado.
CGI.- Common Gateway Interfaz.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 183 de 189
Clase.- Unidad fundamental de programación en Java, que sirve como plantilla para la
creación de objetos. Una clase define datos y métodos y es la unidad de organización
básica de un programa Java.
Common Gateway Interfaz (CGI).- Es un lenguaje de programación que permite
dotar a las páginas Web de interactividad, construyendo una página Web
correspondiente a un enlace de hipertexto en el mismo momento en que se hace "clic"
sobre el enlace. Los script cgi pueden estar escritos en cualquier lenguaje de
programación.
Common Object Requeset Broker Architecture (CORBA).- Estándar para la
conexión entre objetos distribuidos, aunque esté codificados en distintos lenguajes.
Compilador.- Programa de software que traduce código fuente en un lenguaje de
programación legible por una persona a código máquina interpretable por un ordenador.
Constante.- Valor utilizado en un programa de computadoras con la garantía de no
cambiar en tiempo de ejecución. La garantía es a menudo reforzada por el compilador.
En Java las constantes se declaran como static final.
Constructor.- Método que tiene el mismo nombre que la clase que inicia. Toma cero o
más parámetros y proporciona unos datos u operaciones iniciales dentro de una clase,
que no se pueden expresar como una simple asignación.
Contenedor.- En diseño de interfaces de usuario, es un objeto que contiene los
componentes (como botones, barras de deslizamiento y campos de texto).
Conversión de tipos de datos.- Modificación de una expresión de un tipo de datos a
otro.
CORBA.- Common Object Requeset Broker Architecture.
Entero.- Un número entero, sin parte decimal, positivo o negativo.
Estructura de datos.- Una construcción de software (en memoria o en disco duro) que
contiene datos y las relaciones lógicas entre ellos.
Evento.- Un mensaje que significa n incidente importante, normalmente desde fuera del
entorno de software.
Excepción.- Un evento que ocurre durante la ejecución de un programa que interrumpe
el flujo normal de las instrucciones.
Flujo.- Stream.
Graphical User Inteface (GUI).- Interfaz gráfica de usuario.
Hardware.- El aspecto físico de un sistema de computadora, como el procesador, disco
duro e impresora.
Herencia múltiple.- La práctica (permitida en lenguajes como C++ pero no en Java) de
derivar una clase de más de una clase base.
Herencia.- Mecanismo encargado de relacionar clases entre sí de una manera
jerárquica. En Java, sólo existe herencia simple.
Hilo.- Threaa.
HTML (HyperText Markup Languaje).- Lenguaje que se utiliza para crear páginas
Web. Los programas de navegación de la Web muestran estas páginas de acuerdo con
un esquema de representación definido por el programa de navegación.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 184 de 189
IDE.- Integral Development Environment.
IDL.- Java Interface Definition Language.
Ingeniería del software.- Rama de la ingeniería concerniente con el análisis, diseño,
implementación, prueba, y mantenimiento de programas de computadoras.
Instancia.- Objeto de software construido desde una clase. Por ejemplo, puede tener
una clase avión, pero una flota de quince instancias de avión.
Integral Development Enviroment (IDE).- Una herramienta de desarrollo visual en la
que un programa puede ser construido, ejecutado y depurado.
Interbloqueo.- Condición en la que dos o más entidades de software se bloquean
mutuamente, cada una esperando los recursos que está utilizando la otra.
Interface Definition Language (IDL).- Herramienta mediante la cual los objetos
pueden invocar métodos de otros objetos que se encuentren en máquinas remotas,
mediante CORBA.
Interfaz gráfica de usuario (GUI).- Una interfaz entre la máquina y el hombre como el
Windows de Microsoft, el Mac OS, o el Sistema X Windows, que depende de pantallas
de alta resolución, un recurso gráfico de puntero como un ratón y una colección de
controles en pantalla (denominados Widgets) que el usuario puede manejar
directamente.
Interfaz.- Mecanismo Java para decirle al compilador que un conjunto de métodos
serán definidos en futuras clases. (Esas clases estarán definidas para implementar la
interfaz).
1ava 2D.- Paquete que permite a los desarrolladores incorporar texto, imágenes y
gráficos en dos dimensiones de gran calidad.
1ava 3D.- Conjunto de clases para crear aplicaciones y applets con elementos en tres
dimensiones. Es parte del JMF.
1ava DataBase Connectivity (1DBC).- Lenguaje estándar de Java para interactuar con
bases de datos, similar al SQL. Es independiente no sólo de la plataforma sino también
de la base de datos con que interactúe. Desde la versión 1.2 del JDK se permite
interactuar con ODBC.
1ava Developer Connection (1DC).- Conexión de desarrollo en la que se publican las
versiones beta de las bibliotecas de Java que se están desarrollando.
1ava Foundation Classes (1FC).- Conjunto de componentes y características para
construir programas con interfaces gráficas.
1ava Media Framework (1MF).- Protocolo de transmisión de datos para la
reproducción multimedia (vídeo y sonido).
1ava Native Invocation (1NI).- Capacidad de Java para ejecutar código nativo, es
decir, código compilado al lenguaje máquina de un determinado ordenador. Permite a la
Máquina Virtual Java (JVM) interactuar con programas o bibliotecas escritos en otros
lenguajes (C/C++, ensamblador...). No se puede utilizar en applets, pues viola las
directrices de seguridad.
1ava Runtime Environment (1RE).- Software suministrado por Sun que permite a los
programas de Java ejecutarse en una máquina de usuario. El JRE incluye la Máquina
Virtual Java (JVM).
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 185 de 189
1RE.- Java Runtime Environment.
1VM.- Java Virtual Machine.
1ava Virtual Machine (1VM).- El intérprete de Java que ejecuta los códigos de byte en
una plataforma particular.
1avaBeans.- Paquete que permite escribir componentes software Java, que se puedan
incorporar gráficamente a otros componentes.
1DBC.- Java DataBase Connectivity.
1DC.- Java Developer Connection.
1FC.- Java Foundation Classes.
1MF.- Java Media Framewok
1NI.- Java Native Invocation.
1VM.- Java Virtual Machine.
Llamada por referencia.- Una forma de transferir parámetros a una subrutina en la que
se pasa un puntero o referencia a un elemento, de esta forma, la subrutina puede leer y
cambiar el valor del elemento referenciado.
Llamada por valor.- Una forma de transferir parámetros a una subrutina en la que se
pasa la copia del elemento; las modificaciones de la copia no afectan al elemento
original.
Método.- Conjunto de sentencias que operan sobre los datos de la clase para manipular
su estado.
Miniaplicación.- Applet.
Modelo.- En diseño orientado a objetos, una representación del mundo real en unas
abstracciones de software denominadas clases y la relación entre ellas.
Moldeado.- Suplantación del tipo de un objeto o variable por otro nuevo tipo.
Multiproceso.- En sistemas operativos, la habilidad de efectuar dos o más programas
independientes, comúnmente en un procesador solo (a través de Multitarea).
Navegador Web.- Software que permite al usuario conectarse a un servidor de Web
utilizando Hypertext Transfer Protocol (HTTP). Microsoft Internet Explorer, Netscape
Navigator, HotJava de Sun, son populares navegadores de Web.
Navegador.- Navegador Web.
null.- Valor de Java que significa vacio.
Object DataBase Conectivity (ODBC). Lenguaje estándar de Microsoft; que utiliza un
driver del fabricante de una base de datos, para interactuar con ella, más orientado a
C/C++ que a Java.
ODBC.- Object DataBase Conectivity.
Paquete.- Nombre de Java para una biblioteca de clases.
Parámetros formales.- Nombres utilizados dentro de una subrutina por sus parámetros.
Parámetros.- Valores u objetos pasados entre una subrutina y la rutina de llamada.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 186 de 189
Plug-in.- Un programa de una plataforma específica diseñado para ser llamado por un
navegador Web. Utilizado con frecuencia para mostrar información que el mismo
navegador no puede mostrar.
Poliforfismo.- En diseño orientado a objetos, la habilidad de utilizar una clase derivada
en lugar de su clase base. Por ejemplo, un programador puede escribir un método
expresarse() para la clase Mamífero. Un Perro, una Vaca y un Gato se derivan de
Mamífero, y todos pueden expresarse(), aunque sus voces sean bastantes diferentes.
Proceso.- Instancia de un programa ejecutable. Por ejemplo, si inicia dos copias de un
intérprete de Java, tiene dos procesos de la máquina virtual de Java ejecutándose en su
computadora.
Seudocódigo.- Documentación de diseño que describe el trabajo de un programa en
inglés estructurado (o en otro lenguaje) en lugar de un lenguaje de computadora.
Recolector de basura.- En Java, el mecanismo por el cual se recobra y libera la
memoria asociada con objetos no utilizados.
Remote Method Invocation (RMI).- Herramienta que incorpora métodos Java ara
localizar objetos remotos, comunicarse con ellos e incluso enviar objetos como
parámetros de un objeto a otro.
RMI.- Remote Method Invocation.
Secure Sockets Layer (SSL).- Sistema para la creación de conexiones seguras en red.
Servlets.- Módulos que permiten sustituir o utilizar el lenguaje Java en lugar de
programas CGI.
Shell.- Intérprete de órdenes de un sistema operativo.
Sistema operativo.- Software responsable de asignar a los usuarios los recursos de
sistemas de computadoras (incluyendo procesos). UNIX, Windows, NT y Mac OS, son
ejemplos de sistemas operativos.
SQL.- Structured Query Language.
SSL.- Secure Sockets Layer.
Estático.- En diseño orientado a objetos, representa la pertenencia a la clase, en vez de a
una instancia. Es un espacio compartido por todas las instancias de una clase.
Stream.- Flujo de datos. Por ejemplo las entradas y salidas de un programa.
String.- Objeto Java estandarizado en el lenguaje, que representa una cadena de
caracteres.
Structured Query Language (SQL).- Lenguaje para realizar consultas a Bases de
Datos relacionales.
Subclase.- Clase descendiente de otra clase de la que hereda métodos y variables.
Superclase.- Clase de la cual heredan sus métodos y variables otras clases denominadas
subclases.
Swing.- Paquete que permite incorporar elementos gráficos en las aplicaciones, de una
manera más potente que con el AWT. Aparece en la versión 1.2 del JDK. Es no de los
componentes que están incluidos en las Java Fundation Classes, o JFC.
Thread.- Un "proceso ligero" que puede ser arrancado y utilizado más rápidamente que
por un fork o spawn. Jease también: fork. spawn v Proceso.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 187 de 189
Tiempo de vida.- El número de líneas sobre las que una variable es activa, esto es, el
número de líneas entre la primera y la última referencia a la variable.
Tipo primitivo.- En Java, un tipo de dato que no es un objeto. Los tipos primitivos
incluyen caracteres, enteros, número de coma flotante y booleanos.
UML.- Unified Modeling Language.
Unicode.- Conjunto de caracteres de 16 bits, en lugar de los 8 que soportaba ASCII. Así
se pueden representar la mayor parte de los lenguajes del mundo.
Unified Modeling Language (UML).- Notación estándar de facto utilizada en el
análisis y diseño orientado a objetos, basado en el trabajo de Grady Booch, James
Rumbaugh, e Ivar Jacobson.
Vector.- Estructura de datos que coloca un tipo de datos en celdas continuas.
Verificador de código de byte.- Rutinas en la máquina virtual de Java, que aseguran
que las instrucciones en el archivo de clase no violan ciertas restricciones de seguridad.
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 188 de 189
BIBLIOGRAFÍA
Se ha dividido este apartado en diversos puntos, intentando explicar qué referencias
bibliográficas han sido utilizadas en mayor o menor medida para realizar este tutorial.
En cada reseña bibliográfica se indican el número de páginas que tiene, y un comentario
personal indicando su utilidad para una mayor profundización en Java.
A. BIBLIOGRAFÍA CONSULTADA PARA LA ACTUAL VERSIÓN:
& }Arnold y Gosling, 1997] Ken Arnold y 1ames Gosling. Addison-Wesley/Domo.
"El lenguaie ae Programacion Java`. Wesley Iberoamericana. 1997. 334 páginas.
(Muv basico. escrito por el aesarrollaaor ael lenguaie).
& }Eckel, 1997] Bruce Eckel. "Hanas -on Java Seminar". Presindent MindView Inc.
1997. 577 páginas. (Tutorial completo en Ingles en formato PDF).
& }García et al., 1999]. 1avier Garciá de 1alón, 1osé Ignacio Rodríguez, Iñigo
Mingo, Aitor Imaz, Alfonso Brazález, Alberto Larzabal, 1esús Calleja y 1on
García. "Aprenaa Java como si estuviera en primero". Universidad de Navarra.
1999. 140 páginas. (Tutorial muv basico. en el que se trata la potencia ae Java.
pero sin profunaizar en ningun tema en particular).
& }García, 1997] Francisco 1osé García Peñalvo. "Apuntes ae teoria ae la
asignatura Programacion Avanzaaa ael tercer curso ae Ingenieria Tecnica en
Informatica ae Gestion". Universidad de Burgos. 1997. 216 páginas. (Comentan la
teoria ae la programacion orientacion al obieto. Han siao resumiaos para aar una
vision ae la programacion orientaaa a obieto en el apartaao I.1).
& }1ohnson, 1996] 1eff 1ohnson. "Coaing Stanaaras for C. C¹¹. ana Java". Vision
2000 CCS Package and Application Team. 1996. 14 páginas. (Conseios para el
formato ae los fuentes Java. C v C¹¹).
& }Morgan, 1999] Mike Morgan. "Descubre Java 1.2". Prentice Hall. 1999. 675
páginas. (Sin auaa muv interesante. sobre toao por su actualiaaa al tratar con Java
2. v por su extension al tratar toaas las bibliotecas ae Java).
& }Naughton, 1996] Patrick Naughton. "Manual ae Java". Mc. Graw Hill 1996. 395
páginas. (Introauce toaos los aspectos ae la programacion basica en Java).
& }Rojo, 1998] Ignacio Rojo Fraile. "Comparativa ae herramientas Java". Artículo
de la revista Solo Programadores nº49. Tower. Octubre 1998. (Compara 5 IDEs
Java).
& }Sanz, 1998] 1avier Sanz Alamillo. "Noveaaaes v cambios con Java 2". Artículo
de la revista Solo Programadores nº55. Tower. Marzo 1999. (Buen resumen ae los
cambios que han surgiao en el JDK 1.2).
& }Sun, 1998] Sun Microsystems Inc. "JDK 1.2 Documentation". www.sun.com.
1997. (Documentacion ae la API ae Java ael JDK).
& }van Hoff et al., 1996] Arthur van Hoff, Sami Shaioi y Orca Starbuck. "Hookea
on Java". Addison-Weslet. 1996. (Toao lo que hace falta saber para crear applets.
con muchos eiemplos. En ingles).
Guía de iniciación al lenguaje Java.
Versión 2.0. Octubre de 1999
Página 189 de 189
& }Zolli, 1997] Andrew Zolli. "La biblia ae Java". Anaya multimedia. 1997. 814
páginas. (Completo en lo a que bibliotecas ael JDK 1.1 se refiere).
B. BIBLIOGRAFÍA ADICIONAL O CITADA EN LA ACTUAL VERSIÓN:
& }Piattini et al., 1996] Mario G. Piattini, 1osé A. Calvo-Manzano, 1oaquín
Cervera y Luis Fernández. "Analisis v aiseño aetallaao ae Aplicaciones
informaticas ae gestion". Ra-Ma. 1996.
& }Rambaugh et al., 1998] 1. Rambaugh 1., M. Blaha, W. Premerlani, F. Eddy y
W. Lorensen. "Moaelaao v Diseño Orientaaos a Obietos. Metoaologia OMT".
Prentice Hall, 2º reimpresión. 1998.
& }Rational, 1997] Rational Software Corporation. "The Unifiea Moaeling
Language Documentation Set 1.1". www.rational.com. Septiembre de 1997.
& }Rifflet, 1998] 1ean-Marie Rifflet "Comunicaciones en UNIX". McGraw Hill.
1998.
C. BIBLIOGRAFÍA ADICIONAL QUE SE UTILIZÓ EN LA VERSIÓN 1.0
& }Cortés et al.,1996] 1osé Luis Cortés, Nuria González, Virginia Pérez, Paqui
Villena y Ana Rosa Freire. "Java. el lenguaie ae programacion ae Internet". Data
Becker 1996.
& }Cuenca, 1996] Pedro Manuel Cuenca 1iménez. “Programacion en Java para
Internet”. Anaya Multimedia. 1996.
& }Cuenca, 1997] Pedro Manuel Cuenca 1iménez,. "Programacion en Java".
Ediciones Anaya Multimedia. 1997.
& }Framiñán, 1997] 1osé Manuel Framiñán Torres. "Manual Imprescinaible ae
Java". Ediciones Anaya Multimedia. 1997.
& }Lalani, 1997] Suleiman 'Sam' Lalani. "Java. biblioteca ael programaaor".
Ediciones McGraw Hill. 1997.
& }Froufe, 1997] Agustín Froufe. “Tutorial ae Java”. Facultad de Informática de
Sevilla. 1997. http://www.fie.us.es/info/internet/JAVA/.
D. DIRECCIONES DE INTERÉS
Se recomienda suscribirse a la lista de correo de Sun sobre Java, cuya dirección es:
javanews@US.IBM.COM

TXH VLUYD GH LQLFLDFLyQ D OD SURJUDPDFLyQ HQ HO OHQJXDMH -DYD (Q pO VH WUDWDQ ORV GLYHUVRV DVSHFWRV EiVLFRV TXH FRPSUHQGHQ HO DSUHQGL]DMH GH XQ OHQJXDMH GH SURJUDPDFLyQ DVt FRPR XQD EUHYH QRFLyQ GH OD 3URJUDPDFLyQ 2ULHQWDGD DO 2EMHWR HQ OD TXH -DYD VH EDVD $Vt PLVPR VH LQFOX\HQ FRPSDUDWLYDV FRQ RWURV OHQJXDMHV GH SURJUDPDFLyQ HVSHFLDO KLQFDSLp HQ &

 \ VH WUDWDQ FRQ XQ SRFR PiV GH SURIXQGLGDG ELEOLRWHFDV JUiILFDV FRPR $:7 \ 6ZLQJ 6H FRPHQWDQ WDPELpQ DVSHFWRV UHODFLRQDGRV FRQ ,QWHUQHW FRPR VRQ ODV ELEOLRWHFDV GH 6RFNHWV \ ODV IDPRVDV DSSOHWV -DYD 3$/$%5$6 &/$9( -DYD 7XWRULDO /HQJXDMH GH SURJUDPDFLyQ 3URJUDPDFLyQ 2ULHQWDGD D 2EMHWRV $SSOHW &yGLJR GH %\WH &ODVH 2EMHWR ,QWHUQHW 6RFNHW 6XQ -'. 7XWRULDO &yGLJR IXHQWH &

Página 1 de 189

........................................ Relaciones entre objetos ............................ Primeros proyectos en que se aplicó Java....................1752'8&&...................... &203$5$7.................... Cadenas...... Potente ...................................................................Ï1 25................................................................... 37 Página 2 de 189 ..............................&( '( &217(1...................................................... 17 E...... 17 D.............. 2 Índice de imágenes... Modelo de objetos ...................................Ï1 $ /$ 352*5$0$&.........................................................................................................Guía de iniciación al lenguaje Java........ Y mucho más ................................................................................ Otras características ....(17$'26 $ 2%-(72   A.......................................................................................................................................................................................................................................................................................................................... +.......................................... 6 $8725(6 35Ï/2*2 Prólogo de la primera versión de la guía de Java ....................................................................... Simple... ¿Por qué se diseñó Java? ............ 21 B. ............................... 23 D............. 9 Prólogo de la segunda versión de la guía de Java...................$ '( -$9$  A....... 32 D............................................ 37 B...................................................................... Las clases............................................................'26 Resumen............................................................................. 6 Índice de tablas...................................................... 26 C................. 19 .......................... Operadores relacionales y aritméticos......................................0.......... Especulación sobre el futuro de Java ....................... Introducción ....................................................... Futuro de Java..................................................................... 12 Agradecimientos .................................................................................................... 1 Palabras clave............................................................................................................................................................................................................ 11 35()$&............... 23 E...................................... Interactivo y orientado a red... 22 C........................6725.. 16 C............................................................ 31 B..................................................................................... Los objetos ................................ )81'$0(1726   A............................. 27 E................................................................................................................................ 24 F................................................................................................. &$5$&7(5Ë67.................................... Vectores.................................................................................... 32 7(0$ ........................ 31 C........&$6 '( -$9$   A....................................... 32 F.......................... 14 7(0$ . Programación Orientada a Objetos....................................................... Resurgimiento de Java..............................(17$'$ $ 2%-(726   A......................................................................... .......................................................................... Octubre de 1999 Ë1'...............................................................................................1752'8&&....................................................................................................... ...............................................9$ &21 27526 /(1*8$-(6 '( 352*5$0$&.............................................................................................. Introducción .................................................................. Comparación de los tipos de datos ............................................... 25 ........................................................Ï1 25...................................................................... )81'$0(1726 '(/ /(1*8$-(  .....................................................................2 Contenidos .......... 27 D...................................... 32 E... Tokens ...... ................... Comienzos ....................................................................................................................................................................&(6  Índice de contenidos............................. 29 ................. Introducción ..... 16 B...........Ï1 ... Versión 2..........&(6 Ë1'....................................... 1 Ë1'................................................................................... 26 B............

....................................................... la composición .......................................................... 7................. Vectores y Matrices .................................................. Colisiones en la herencia múltiple .......................................................................... Introducción ................................................................................................................ Excepciones ............................................. 45 ................................................... Creación de un paquete...... Envolturas de los tipos simples ....................................... 68 ................................ /$ +(5(1&................................ Ámbito de los elementos de un paquete .......... La instanciación de las clases: Los objetos.................................................. La clase Object............................................................. 52 ......................... Introducción ............ Jerarquía . 58 E........................................................................... 79 .................................................................................. El polimorfismo................................ Implementación de una interfaz.. 3$48(7(6  A...................................................................................................... ................. 71 F...... 85 ......$   A. Limitaciones en la herencia ................................................................................. 54 B......... Precedencia de operadores ........... 23(5$&............................................................................................ Funcionamiento .................... *(67...................................................... 88 F.................. Las sentencias condicionales: if y switch ....... 70 B.......................................................................................................... 45 C.............................. 52 F............................................................................................................................................. Herencia múltiple ............................................................... 67 E........................ 49 D..... 72 ..................... Herencia múltiple ........................................ 90 B.......................................... 90 C....... Acceso al objeto ........................................................... 62 B........................................................................... 80 B...................................................................................................................................................................................................................................................................................................................... 47 B........................................................................................................................................................................................................................ Tipos de excepciones................. 74 C................ 78 E......................... Introducción ..........&(3&..Guía de iniciación al lenguaje Java............ continue y return.............................................................. 87 D...................................... Introducción ....................................... (6758&785$6 '( &21752/  A...................... 48 C.......................... .............................................. Operadores de bit ................................... 88 E..... las referencias polimórficas: this y super ........2.................................. 87 B...................... 42 B.......... Octubre de 1999 C............................................................ 39 D................................................ La destrucción del objeto............................................................................................... Introducción ...................... Cadenas ............................................................................................................................................... do.................................. Tipos de datos simples .......................................................................................................... 71 E................................................................................................. 74 B................................................................ Definición de una clase............0...............................................................Ï1 '( (.................... 89 .......... 63 C...............326 '( '$726   A...................... Uso de un paquete ..... 76 D............... ..................................................... Introducción ................21(6 < (5525(6  A............................................. Sentencias de iteración o bucles: for................................................................................................... Operadores de asignación ............ 65 D..................... 91 Página 3 de 189 ............. 70 D......................................................21(6 $9$1=$'$6 (1 /$6 &/$6(6   A................................................................. Expresiones....................... Operadores aritméticos .. Declaración.... Operaciones avanzadas en la herencia....................... Versión 2............................................................. while................. 81 D...17(5)$&(6   A.............................. 61 ........................................................................... Bloques y ámbito..................................................... 54 C...... Introducción ............................................................................................................................................................................................................................................................ 23(5$'25(6  A. 87 C........................... 50 E.......................................... Excepciones que incorpora Java 1......................................................................... 57 D.... Sentencias de salto: break...................................................................... 91 D...... Introducción ......................................................... 80 C......................... Operadores de comparación y condicionales.... 70 C........................................ Declaración............................................................................................................................................................................................................................. ....... &/$6(6 < 2%-(726   A........................................................................ 40 ..................................

.................................... 107 D...............................9 %................... 105 C...................&$6 ....................................... Para más información ............ /26 7+5($'6 2 352*5$0$&....27(&$6 '( /$ $3............................................................... 102 B...................................... Entrada/Salida por fichero .......... %.................................. Entrada/Salida estándar ...........................................%/............................................... 97 C................ Versión 2.....0................................................... Sincronización de threads... Introducción .................... Métodos de la clase String...'$  A................................................................... Paquetes de utilidades... Introducción ........................................... 93 C....................................... %................... &$'(1$6   A....................................................... 102 C........................................................................................................................+.......................... Subpaquetes de Swing................... Paquetes para el desarrollo gráfico ................ 112 7(0$ ........................27(&$6 '( /$ $3............. Modelo de eventos............................./...... 108 ................................................................9 /26 3$48(7(6 *5È)............................................................... Ejemplos de uso de cadenas ...................................... 102 D..................................................................................... 120 D................... 96 .... Octubre de 1999 . Utilización de thread........................................................................................... 98 D.......... 121 ........................ 111 C...........................27(&$6 *5È).................................................................%/............................... 103 E................ .................................................../2  A............................................................................................................Ï1 08/7.................&26 '( /$6 -)&  A.... Subpaquetes de AWT .................... Introducción .......... Tipos de aplicaciones......................... Introducción ............... Recomendaciones de programación ..................................................................... Grandes programas...................................................................................... Y mucho más................................. 119 C.................. '( -$9$  .................................... Introducción .............................................. '( -$9$   A...................... 111 B............................... 99 7(0$ ............................................................................ Métodos de la clase StringBuffer ...........Ï1 '( 352*5$0$6 -$9$   A....... 119 B.............................................Guía de iniciación al lenguaje Java.......... 103 ................ Paquetes para el desarrollo en red .................................................................................................. 94 D............. 93 B....................... 97 B.......... &5($&.................................................................................................................................. (175$'$6$/..........................................9 $:7 $EVWUDFW :LQGRZLQJ 7RRONLW.............................................................................................................................................. 104 B................................................................. Introducción .....................

........................................................................................................................ Introducción ................................................................................................................................................................................................................17(51(7  9 -$9$ ( ................................................................................. 130 G......................................... Eventos de AWT.......................................................................................1*   A......... Component ................................................................................................................. 133 B......................................... Gestores de impresión ................  A.......................................................................... Introducción ... 134 9 /26 62&.................................................................................. 124 F.... 122 B..................................... 128 D............................ Introducción ....................... El paquete java................................................ 127 C.................9 6:.............................................................net........................ JrootPane ................................................................................................................... Nuevos eventos de Swing ..... 125 .......................................................... 129 F................ 129 E............................................. 122 C............................... Principales clases.......................... Container ....................... 130 7(0$ 9 -$9$ ( ........ 134 C................................................................................. 124 E......................... 124 D............................... Futuro del Java en Internet ....(76 (1 -$9$   Página 4 de 189 ............................................................................................................. El patrón de diseño Modelo-Vista-Controlador ....................... Nuevos gestores de impresión .......... Nuevas características............. 127 B......................... Otras clases ...........................................17(51(7   A.......................................................................................................

...................... Métodos del ciclo de vida.. Código ........... Animación y sonido: “Animator”.......... Ejecución .... Manipulación del entorno de una applet...............................................................................Ï1 '( 81$ $33/(7   A............................ (-(03/2 '( &216758&&. Inclusión de la applet en una página Web ............................... 145 9.....................1752'8&&.................................................................. 135 B.......................................... 143 E................................. Creación de una aplicación que utilice la applet (AWT)............................ Introducción ............................................................................................................................................... Situación de la clase Applet en la API de Java........................................................Ï1 $ /$6 $33/(76   A..............................................................&( .......... 150 B...................................... 144 G... 153 F... 155 $3e1'..................................................... 152 D......................................................................................................................................... 140 9............................................................ 144 F..................... Ejemplo de uso ........... 14 2 B.............................. Trucos de texto: “Nervous Text”............................................ 146 C..................... La clase URL........................... 142 C.................................................................................................... 149 9....................................................................................................................... Obtención de los parámetros de la applet ..................&(6  $3e1'................................................................. (-(03/26 '( $33/(76   A.............................. Creación de una aplicación que utilice la applet (Swing) ................................. Fundamentos .......................................... Financias y negocios: “Bar Chart”.................................................................LW.Guía de iniciación al lenguaje Java................................................. Versión 2.............................................. /$ &/$6( $33/(7   A........................................ 145 H..................... 140 B..... 136 7(0$ 9.. Juegos y educacionales: “Graph Layout”.................... Soporte multimedia ................. Obtención de Información sobre una applet ..................................... 147 D....................... 153 E........................... Gráficos interactivos: “Link Button”..........0............. 147 E............................... $33/(76 -$9$ 9..... Consideraciones sobre la seguridad en las applets ........... 146 B............................................................ Octubre de 1999 A............... Instantáneas: “Tumbling Duke” .................................................... -DYD 'HYHORSPHQW ..... 151 C................................................................................ (/ -'............. ........................ Creación de applets más avanzadas ........................................................................................... 143 D.............................

................ Entornos de desarrollo ........................................... 167 $3e1'........................................... Novedades en la versión 1...................................................................................... +(55$0................................. 162 $3e1'.....................................2 del JDK (Java 2)...................... Uso del JDK ................... 164 B......   A........ 164 C............ 158 B............. 162 E........................................................................................................ Bibliotecas de programación ...............................................(17$6 '( '(6$552//2  A..........................................................&( ........... 0e72'26 1$7.................................................................................. 161 D....... Introducción ........................926 -$9$ -1............................................ Programas de navegación........................................ Componentes del JDK ....&( .................................................. Obtención e instalación del JDK .................................. 158 C...........................................

.................................................. 171 C.......................   A....................... Tipos de datos...... Estructuras de control... Introducción ............................................... 177 E.................................................................... 178 Página 5 de 189 ................................................................... Ejemplo de uso de métodos nativos........................................................................................................................ 168 B............................ 175 B........................................................................................... 175 C....................................................................................... 176 D......9 *8Ë$ '( 5()(5(1&................................................&( .......................... Diferencias de ejecución ..................................................................&( 9 *8Ë$ '( 5()(5(1&...................................................... Diferencias de diseño.................................................................................................... 171 B.. 172 D.................................................................. Fundamentos ....... Introducción ......................$ '(/ /(1*8$-( -$9$   A...................................................... 173 $3e1'........................................ Diferencias sintáticas.................................................................................................................... ......... 168 $3e1'..... Operadores................ Clases.......................................$ '( & $ -$9$   A.....................................................

............................2 %..............&( '( ...PDJHQ  +HUHQFLD GH H[FHSFLRQHV -DYD  ................................... Bibliografía adicional o citada en la actual versión:..........PDJHQ  $SSOHW GH ILQDQFLDV \ QHJRFLRV ³%DU &KDUW´  ............. 188 B............ Paquetes.................PDJHQ  ................%/...... Excepciones...................................................0....PDJHQ  -HUDUTXtD GH ODV FODVHV GH $:7  .................................. 179 J..............PDJHQ  /RJRWLSR GH OD HPSUHVD 6XQ 0LFURV\VWHPV ...................PDJHQ  $SSOHW ³/tQHD´ ....PDJHQ  )XQFLRQDPLHQWR GH XQD FRQH[LyQ VRFNHW ........PDJHQ  &LFOR GH YLGD GH XQD DSSOHW  ........ Bibliografía adicional que se utilizó en la versión 1... Atributos ................ Octubre de 1999 F.....................................................................................PDJHQ  (MHPSOR GH KHUHQFLD P~OWLSOH  ............................... 181 */26$5.......... 189 C................................................................... Ë1'..... 179 I.................................................................................................................................. Interfaces..................................................... 179 H................................................................ Direcciones de interés ........... Threads ...............Guía de iniciación al lenguaje Java............................ Bibliografía consultada para la actual versión:..................................................&( '( 7$%/$6 7DEOD  &RPSDUDFLyQ HQWUH -DYD 6PDOO7DON \ &  7DEOD  3DODEUDV UHVHUYDGDV -DYD  Página 6 de 189 ...........................................................................................2*5$)Ë$  A.................. 178 G. 180 K........................PDJHQ  'LIHUHQWHV DVSHFWRV GH XQD LQWHUID] 6ZLQJ  ................PDJHQ  (MHFXFLyQ GH XQ FyGLJR GH E\WH .......................0È*(1(6 .......PDJHQ  (MHPSOR GH RWUR iUERO GH KHUHQFLD ...... 189 Ë1'......PDJHQ  $SSOHW GH WH[WR DQLPDGR ³1HUYRXV 7H[W´  .....PDJHQ  $SSOHW GH MXHJRV \ HGXFDFLRQDOHV ³*UDSK /D\RXW´ ......................PDJHQ  $SSOHW GH JUiILFRV LQWHUDFWLYRV ³/LQN %XWWRQ´  .................. Métodos.... Objetos ...............PDJHQ  $SSOHW GH $QLPDFLyQ \ VRQLGR ³$QLPDWRU´ ......................................................... Versión 2..............................PDJHQ  8WLOL]DFLyQ GHO -'........ 189 D..................PDJHQ  $SSOHW .............. 180 L.......FRQR GH 'XNH OD PDVFRWD GH -DYD .........0......................QVWDQWiQHD ³7XPEOLQJ 'XNH´  ..............PDJHQ  (MHPSOR GH iUERO GH KHUHQFLD ........

Versión 2.Guía de iniciación al lenguaje Java. Octubre de 1999 7DEOD  2SHUDGRUHV -DYD  7DEOD  )RUPDWRV GH FRPHQWDULRV -DYD  7DEOD  7LSRV GH GDWRV HQWHURV 7DEOD  7LSRV GH GDWRV QXPpULFRV HQ FRPD IORWDQWH 7DEOD  &DUDFWHUHV HVSHFLDOHV -DYD  7DEOD  &RQYHUVLRQHV VLQ SpUGLGDV GH LQIRUPDFLyQ 7DEOD  2SHUDGRUHV DULWPpWLFRV ELQDULRV GH -DYD 7DEOD  9HUVLRQHV XQDULDV GH ORV RSHUDGRUHV  \   7DEOD  2SHUDFLRQHV FRQ  \   7DEOD  2SHUDGRUHV GH FRPSDUDFLyQ 7DEOD  2SHUDGRUHV FRQGLFLRQDOHV  7DEOD  2SHUDGRUHV GH GHVSOD]DPLHQWR GH ELWV  7DEOD  2SHUDGRUHV GH OyJLFD GH ELWV 7DEOD  2SHUDGRUHV GH DWDMR GH DVLJQDFLyQ  7DEOD  3UHGHGHQFLD GH RSHUDGRUHV 7DEOD  (VWUXFWXUDV GH FRQWURO  7DEOD  9LVLELOLGDG GHQWUR GH XQ SDTXHWH 7DEOD  &RQYHUVLRQHV GH FDGHQDV D WLSRV VLPSOHV Página 7 de 189 .0.

de Ingeniería Civil Universidad de Burgos &225'.Guía de iniciación al lenguaje Java.0. Octubre de 1999 $8725(6 '.&$'2 325 Ignacio Cruzado Nuño Becario del Área de Lenguajes y Sistemas Informáticos Departamento de Ingeniería Civil Universidad de Burgos 27526 . Alumnos del curso 1997-1998 (Primera promoción).5(&725 '(/ 352<(&72 Miguel Ángel Manzanedo del Campo Área de Organización de Empresas Dpto.19(67.&2 Francisco José García Peñalvo Área de Ciencias de la Computación e Inteligencia Artificial Dpto.$'2 < 38%/.es Página 8 de 189 . Rubén Cobos Pomares Raquel Díez Alcalde Jorge García del Egido Pablo Santos Luances Ignacio Cruzado Nuño Alberto Díez Cremer Fernando Delgado Peña Ana Berta García Benito Javier Portugal Alonso Esteban José García Zamora Alberto Gómez Revilla David Suárez Villasante Ismael González Domingue Mª Begoña Martín Ortega Dirección electrónica del proyecto: qjava@ubu. de Informática y Automática Universidad de Salamanca 5('$&7$'2 ('. asignatura optativa del 3º Curso de la Titulación de “Ingeniería Técnica en Informática de Gestión” en la Universidad de Burgos.Ï1  Alumnos de la asignatura de “Programación Avanzada”. Versión 2.1$'25 7e&1.*$'25(6 César Ignacio García Osorio Jesús Manuel Maudes Raedo Carlos Pardo Aguilar Área de Lenguajes y Sistemas Informáticos Área de Lenguajes y Sistemas Informáticos Departamento de Ingeniería Civil Universidad de Burgos Departamento de Informática Universidad de Valladolid Juan José Rodríguez Díez $/80126 &2/$%25$'25(6 (1 /$ 9(56.7$'2 $03/.

Los objetivos docentes estaban centrados en la búsqueda de la mejora de la calidad docente. Versión 2. A continuación se recogen tanto los objetivos docentes como los objetivos pragmáticos propuestos. La actividad que se propuso llevar a cabo fue una Guía Hipermedia para el Aprendizaje del Lenguaje Java. Sin embargo. en contraposición de la actitud pasiva que tradicionalmente asume el alumno en las clases.Ï1 '( /$ *8Ë$ '( -$9$ Java es actualmente uno de esos términos mágicos que revolucionan las tecnologías de la información cada cierto tiempo. Java comienza a entrar en las Universidades Españolas. Java es un lenguaje de programación orientado a objetos creado por la compañía Sun Microsystems.0. Los objetivos pragmáticos se centraban en el acercamiento del lenguaje Java al curriculum de los alumnos matriculados en la asignatura “Programación Avanzada” correspondiente al tercer curso de la titulación “Ingeniería Técnica en Informática de Gestión en la Universidad de Burgos”. Œ Œ Œ Página 9 de 189 . Dotar a alumnos y profesores de las responsabilidades que conlleva la realización de una actividad en grupo. a la vez que se exploraba una nueva forma de involucrar de una manera más activa al alumnado en las actividades docentes.0(5$ 9(56. especialmente de la mano de los proyectos de final de carrera en las titulaciones de informática. así como de incentivar al profesorado en aras de conseguir una docencia de mayor calidad. 2EMHWLYRV 'RFHQWHV Œ Establecer una nueva forma de participación activa de los alumnos en el desarrollo de su currículum universitario.Guía de iniciación al lenguaje Java. Aumentar la cantidad y la calidad de la relación profesor-alumno. todo ello estrechamente ligado a Internet y al WWW. reflejada en una mayor participación de los alumnos y en una mejora de la relación profesor-alumno. El éxito del lenguaje Java viene de la mano de la filosofía y la forma de operación de las aplicaciones escritas en Java. Octubre de 1999 35Ï/2*2 35Ï/2*2 '( /$ 35. se decidió realizar una actividad que tuviera como protagonista al lenguaje Java. El hecho de que el lenguaje Java sea un lenguaje joven en evolución no le ha permitido entrar a formar parte habitualmente de los currículum universitarios. Completar los contenidos del curriculum universitario del alumno con temas novedosos que no suelen tener cabida en el programa de las asignaturas. Aprovechando la convocatoria de 1998 de la Consejería de Educación y Cultura de la Junta de Castilla y León para la concesión de ayudas para la elaboración de Recursos de Apoyo a la Enseñanza Universitaria en esta Comunidad Autonómica. Con la realización de esta guía se perseguían una serie de objetivos tanto docentes como pragmáticos. poco dados a admitir innovaciones con tanta celeridad. que desde su aparición en 1995 ha provocado una autentica conmoción en los entornos informáticos.

QJHQLHUtD 7pFQLFD HQ . 5 de Octubre de 1998 Miguel Ángel Manzanedo del Campo Francisco José García Peñalvo Página 10 de 189 . Versión 2. Aprender de la experiencia para repetir esta técnica en otras asignaturas de la titulación e incluso en otras Universidades. como para material docente o como material de consulta en los proyectos de final de carrera. La metodología empleada para la creación de esta guía ha consistido en formar grupos de trabajo formados por tres alumnos cada uno (ORV DOXPQRV TXH IRUPDEDQ FDGD XQR GH ORV JUXSRV HUDQ DOXPQRV GH OD DVLJQDWXUD 3URJUDPDFLyQ $YDQ]DGD GHO WHUFHU FXUVR GH OD . Octubre de 1999 2EMHWLYRV 3UDJPiWLFRV Œ Œ Introducir el lenguaje Java dentro de la titulación Ingeniería Técnica en Informática de Gestión de la Universidad de Burgos. Elaborar una guía de referencia hipermedia del lenguaje Java accesible vía Internet y distribuíble en CD-ROM. Cada grupo se encargaba de elaborar una serie de temas que en su conjunto dan forma a la presente guía. Una vez que los temas estaban terminados eran revisados e integrados en la guía por el coordinador técnico del proyecto. debido a que sus características hipermedia lo hacen idóneo para el desarrollo de este tipo de productos. Una segunda fase ((QHUR  ± 'LFLHPEUH ) donde se amplía la primera guía introductoria con los conceptos más avanzados del lenguaje y se enriquece de los comentarios recibidos sobre la primera guía. Para la realización práctica de esta primera guía se ha utilizado exclusivamente HTML (Hyper Text Markup Language). Burgos.Guía de iniciación al lenguaje Java. Œ Este proyecto se va a acometer en dos fases bien diferenciadas: Una primera fase ((QHUR  ± 'LFLHPEUH ) donde se planifica todo el proyecto y se obtiene una primera guía básica de referencia básica (SURGXFWR TXH YLHQH UHSUHVHQWDGR SRU OD SUHVHQWH JXtD). siendo su trabajo coordinado por alguno de los profesores colaboradores.0. Esta guía podrá ser utilizada tanto para el autoaprendizaje.QIRUPiWLFD GH *HVWLyQ GH OD 8QLYHUVLGDG GH %XUJRV TXH YROXQWDULDPHQWH VH RIUHFLHURQ SDUD FRODERUDU HQ HVWD LQLFLDWLYD).

no dudaría en destacar el valor humano logrado al potenciar la relación profesor-alumno (hoy en día ex-alumnos) y entre compañeros de diferentes Universidades de Castilla y León para lograr el fin extra académico propuesto. para todos mis antiguos alumnos que se dejaron “engañar” para iniciar esta aventura y para Ignacio Cruzado cuyo trabajo en estos últimos meses ha dotado de contenido y forma a la versión de la guía que hoy se hace realidad. los entornos gráficos de usuario o la incorporación de métodos nativos entre otros interesantes temas. También me gustaría destacar el hecho constatado de que la elaboración de esta guía a contribuido en gran manera a la introducción del lenguaje Java dentro de la titulación de Ingeniería Técnica en Informática de Gestión de la Universidad de Burgos.). tuviera que destacar una sola cosa de esta experiencia.. y está haciendo lo propio en la Ingeniería Técnica en Informática de Sistemas de la Universidad de Salamanca. artículos.. 13 de octubre de 1999 Francisco José García Peñalvo Página 11 de 189 . No quisiera terminar este prólogo sin antes tener unas palabras de agradecimiento y recuerdo para todos aquéllos que participaron de una u otra manera en la elaboración de esta guía. ha abierto numerosos campos de aplicación para esta plataforma (acceso a bases de datos.Ï1 '( /$ *8Ë$ '( -$9$ En los casi dos años en los que se ha venido desarrollando esta guía introductoria al lenguaje Java. Durante este tiempo han proliferado multitud de referencias en torno al fenómeno Java (en forma de libros.0. A parte de la guía realizada. la guía que hemos realizado no pretende sustituir a ninguno de ellos. Si personalmente.. interacción con CORBA. sin embargo. aunque todavía lejos de una madurez plena. Versión 2.Guía de iniciación al lenguaje Java. hemos asistido al afianzamiento de Java como plataforma de desarrollo y a una constante evolución que. Octubre de 1999 35Ï/2*2 '( /$ 6(*81'$ 9(56. así como la ampliación en temas relacionados con la programación cliente/servidor en Internet. como producto final resultado del proyecto financiado por la Consejería de Educación y Cultura de la Junta de Castilla y León en su convocatoria de ayudas de 1998. tutoriales. sino más bien completarlos presentando una forma sencilla y directa de introducirse al lenguaje Java y ofreciendo un acceso sencillo basado en la facilidad de navegación hipermedia que aporta HTML. que dan un enorme valor a esta guía como fuente de referencia práctica.. especialmente para mis ex-compañeros del Área de Lenguajes y Sistemas Informáticos de la Universidad de Burgos. este proyecto ha aportado unas experiencias especialmente interesantes al verse satisfechos los objetivos docentes y pragmáticos que se buscaban al iniciar este trabajo. aplicaciones distribuidas. En el ámbito técnico destacar la revisión realizada de los contenidos de la primera versión de la guía. Salamanca. y que se indicaban en el prólogo a la primera versión de esta guía que aquí se presenta.).

Sus amplias bibliotecas multiplataforma.0. con lo que se vivirá un futuro lleno de esplendor para Java.2 Cuando hace dos cursos el profesor Francisco José García Peñalvo nos propuso redactar el esbozo de un tutorial sobre Java. La continua apuesta de "Fran" por su alumnado. ha sido el pilar de este tutorial. 2.'26 Este tutorial ha sido dividido en una serie de temas (cada uno de ellos compuesto de varios apartados) para una más fácil consulta y una mayor claridad en cuánto a qué se está intentando explicar. y aunque los alumnos siempre somos reacios a una carga de trabajo sin compensación en la calificación. A continuación se detalla de una forma general los contenidos de cada uno de los apartados. era muy vaga. sorprendentemente. sus características principales y una comparativa con otros lenguajes orientados a objeto. Aunque la redacción de la primera versión. Versión 2. de carácter voluntario. Esperemos que pronto los problemas de incompatibilidad entre Microsoft Explorer y Netscape Navigator se solucionen. Aunque desgraciadamente aquel año no toda la clase pudiera superar la asignatura. tanto como esquema de temas a tratar. y la confianza que en nosotros depositó. . Así mismo espero que la bibliografía aportada sea suficiente para aquellos que hayáis quedado prendados de la potencia de este nuevo lenguaje de programación. Espero no haber perdido nunca de vista que este tutorial debe de servir tanto a expertos informáticos como a programadores de cualquier tipo que. realmente nos estimuló a dar todo lo mejor de nosotros. aun no teniendo idea de programación orientada a objetos. como bibliografía a manejar. &217(1. Página 12 de 189 . tengan interés en Java. pocas voces he oído en desacuerdo con las novedosas formas docentes que aquel año se experimentaron. 3. hecha por diferentes grupos de trabajo.Guía de iniciación al lenguaje Java.QWURGXFFLyQ se intenta acercar al lector el mundo Java desde una perspectiva global. los alumnos aceptamos. La posibilidad de desarrollar aplicaciones que funcionen en Internet mediante navegadores (DSSOHWV). heterogénea y estaba llena de erratas. Todo ello con un lenguaje orientado a objeto sencillo pero potente. Debo decir que mientras desarrollaba este tutorial me ha impresionado la potencia de Java por tres motivos principales: 1. su historia. En la redacción de este tutorial se ha pretendido abarcar el mayor número de aspectos posibles de la gran variedad de temas que rodean a Java. Octubre de 1999 35()$&. En el primer tema . sobre todo por la carga docente. para que el lector pueda juzgar si le interesa aprender Java y para que vaya vislumbrando en qué puntos le va a interesar profundizar.

como por ejemplo C o C++. Por último al tutorial se le adjuntan una serie de apéndices que sirvan como breves reseñas sobre diferentes aspectos de Java que por una u otra cuestión se ha decidido que vayan aparte de lo que es el bloque del lenguaje. . los WKUHDGV. Así en el primer apéndice $SpQGLFH . las estructuras que utiliza. se explica la potencia de Java para el desarrollo de aplicaciones en red. se comentan las diferentes herramientas disponibles en el mercado para desarrollar aplicaciones Java. seis y siete introducen los aspectos orientados a objeto del lenguaje Java. Página 13 de 189 .9 %LEOLRWHFDV JUiILFDV . todas las bibliotecas de la API de Java que servirán para dotar a los programas de una gran potencia con multitud de clases e interfaces estándar ya programadas y distribuidas por Sun... -'. Además en este tema se acompañan una serie de ejemplos para intentar aclarar el desarrollo y funcionamiento de este tipo de aplicaciones. depurarlas y probarlas. Por último en el apartado doce se explican los fundamentos sobre la construcción de programas Java. comenzando desde los más sencillos como son los objetos y las clases hasta los más complejos como pueden ser la herencia y el polimorfismo. Además. Entre los apartados ocho y once se comentan diversos aspectos propios del lenguaje Java.. Son características de Java y le aportan una potencia inusitada para el desarrollo de aplicaciones para Internet. las interfaces y los paquetes. se explica en detalle el funcionamiento del JDK. El tercer tema . herramienta que distribuye Sun para el desarrollo de aplicaciones Java.QWHUQHW .0. Los cuatro primeros apartados de este tema son fundamentales para comprender cualquier fragmento de código Java. En el sexto tema 9. En el quinto tema 9 -DYD H . sus sistemas de control. y aunque sencillos son similares a los de cualquier otro lenguaje de programación. En el segundo apéndice $SpQGLFH . como es Java. $SSOHWV se explica el fundamento de este tipo de aplicaciones especialmente diseñadas para su uso en Internet. Los temas cinco. aplicaciones que se pueden construir y diversos aspectos referentes a ellas.. en un par de apartados se explican las gestiones de las cadenas y de los flujos de entrada/salida que hace Java. El segundo tema . Octubre de 1999 En un primer apartado se introducen todos los conceptos necesarios para poder entender un lenguaje de programación orientado a objeto. En el cuarto tema . Versión 2. Este apartado debe ser de especial interés para todos aquellos lectores que no hayan desarrollado jamás programas en un lenguaje orientado a objeto. que dotan a los programas de una mayor potencia como son las excepciones. así como el paquete MDYDQHW el cual da soporte a un montón de operaciones para el diálogo de diversas aplicaciones de red con aspectos como los VRFNHWV. /HQJXDMH define todos los conceptos básicos y sintaxis del lenguaje Java. su sintaxis. de una forma global.. %LEOLRWHFDV GH OD $3..Guía de iniciación al lenguaje Java. y debe facilitar la comprensión de muchos conceptos básicos para un mejor entendimiento del resto del tutorial. GH -DYD trata. se explican las dos bibliotecas que Java incorpora para desarrollar interfaces gráficas de usuario: AWT y la nueva Swing. +HUUDPLHQWDV GH GHVDUUROOR . Estas acciones se realizan de forma sensiblemente diferente a la de otros lenguajes de programación.

a modo de resumen.. Así mismo me gustaría agradecer al Área de Lenguajes y Sistemas Informáticos de la Universidad de Burgos la confianza depositada en mi así como toda la documentación bibliográfica que me han facilitado. Este apéndice puede ser fundamental para aquellos programadores que proviniendo de C++ quieran conocer el lenguaje Java.0. En el último apéndice $SpQGLFH 9 *XtD GH UHIHUHQFLD GHO OHQJXDMH . así como la confianza que deposita en su alumnado. Versión 2. Espero que este tutorial realmente os agrade a todos.. Septiembre de 1999 Página 14 de 189 . engañosa. las características fundamentales del lenguaje Java $*5$'(&. se explican. 0pWRGRV 1DWLYRV se explica mediante un ejemplo de cómo Java es capaz de utilizar código de aplicaciones escritas en otros lenguajes de programación.Guía de iniciación al lenguaje Java. Octubre de 1999 En un tercer apéndice $SpQGLFH .9 *XtD GH UHIHUHQFLD GH -DYD D & se explican las similitudes y diferencias entre estos dos lenguajes de programación. dado que Java es un lenguaje derivado de C++. en muchos casos. Por último me gustaría agradecer muy especialmente a Amelia Pajares Rojo su colaboración espontánea en este proyecto.(1726 Me gustaría aprovechar este momento para felicitar a Francisco José García Peñalvo por el esfuerzo que hace por una docencia más moderna y atractiva. En el cuarto apéndice $SpQGLFH . ya que su similitud sintáctica es.0. consiguiendo así un tutorial mucho más claro y legible. pero con notables diferencias respecto a su predecesor. y por el agradable clima de trabajo que ha creado para la realización de este tutorial. Ignacio Cruzado Nuño Burgos.

Guía de iniciación al lenguaje Java.Ï1 Página 15 de 189 . Versión 2. Octubre de 1999 7(0$ . .1752'8&&.0.

Un objeto es la representación de un concepto para un programa. sino un ente denominado objeto.Guía de iniciación al lenguaje Java.Ï1 25. presenta una interfaz para poder interactuar con el exterior. la extensión y la reutilización del software generado bajo este paradigma. Versión 2. la programación estructurada. Octubre de 1999 . y el estado en que se encuentra en un momento determinado de su existencia.Ï1 25. La programación orientada a objetos trata de amoldarse al modo de pensar del hombre y no al de la máquina. Así mismo la LQVWDQFLDFLyQ GH REMHWRV equivaldría a la GHFODUDFLyQ GH YDULDEOHV. Java incorpora el uso de la orientación a objetos como uno de los pilares básicos de su lenguaje. La mayoría de los objetos sólo existen durante una parte de la ejecución del programa.0. Con él se definen las propiedades del objeto. definida por sus PpWRGRV. Página 16 de 189 . Œ Œ El equivalente de un REMHWR en el paradigma estructurado sería una YDULDEOH. y de un estado que recuerda el efecto de los servicios". Los objetos son creados mediante un mecanismo denominado LQVWDQFLDFLyQ. % /26 2%-(726 Podemos definir objeto como el "encapsulamiento de un conjunto de operaciones (métodos) que pueden ser invocados externamente. en la que estaban separados en forma de variables y funciones. para que el resto de objetos que componen los programas puedan interactuar con él.1752'8&&. El elemento básico de este paradigma no es la función (elemento básico de la programación estructurada). Es por esto por lo que se dice que en la programación orientada a objetos "se unen datos y procesos". Un objeto además de un estado interno. Comportamiento: Todo objeto ha de presentar una interfaz. . y contiene toda la información necesaria para abstraer dicho concepto: los datos que describen su estado y las operaciones que pueden modificar dicho estado. y determinan las capacidades del objeto. definido por sus DWULEXWRV. y no como en su predecesora. >3LDWWLQL HW DO @. y a propiedades como la jerarquía o el encapsulamiento.Ï1 $ /$ 352*5$0$&. y cuando dejan de existir se dice que son GHVWUXLGRV Estado: Todo objeto posee un estado.(17$'$ $ 2%-(726 La orientación a objetos es un paradigma de programación que facilita la creación de software de calidad por sus factores que potencian el mantenimiento. Esto es posible gracias a la forma racional con la que se manejan las abstracciones que representan las entidades del dominio del problema.(17$'$ $ 2%-(726 $ 352*5$0$&. Un objeto consta de: Œ Tiempo de vida: La duración de un objeto en un programa siempre está limitada en el tiempo. y el WLHPSR GH YLGD GH XQ REMHWR al iPELWR GH XQD YDULDEOH.

el paso de mensajes y el poliforfismo. y representan las capacidades del objeto (en muchos textos se les denomina VHUYLFLRV).Guía de iniciación al lenguaje Java. Cuando se crea un objeto (LQVWDQFLDFLyQ) se ha de especificar de qué clase es el objeto instanciado.0.. los atributos a las variables globales de dicho módulo. ' 02'(/2 '( 2%-(726 Existen una serie de principios fundamentales para comprender cómo se modeliza la realidad al crear un programa bajo el paradigma de la orientación a objetos. >3LDWWLQL HW DO @. Es la implementación de un tipo de objeto (considerando los objetos como instancias de las clases)". Versión 2.. D. la modularidad. el encapsulamiento. En dichos métodos se modifican los valores de los atributos del objeto. para que el compilador comprenda las características del objeto. Los PpWRGRV son las funciones mediante las que las clases representan el comportamiento de los objetos. Estos principios son: la abstracción. una clase se asemejaría a un módulo. Octubre de 1999 & /$6 &/$6(6 Las clases son abstracciones que representan a un conjunto de objetos con un comportamiento e interfaz común. Desde el punto de vista de la programación estructurada. Una clase no es más que una plantilla para la creación de objetos. Cuando se instancia un objeto el compilador crea en la memoria dinámica un espacio para tantas variables como atributos tenga la clase a la que pertenece el objeto. y los métodos a las funciones del módulo. Las clases presentan el estado de los objetos a los que representan mediante variables denominadas DWULEXWRV. Podemos definir una clase como "un conjunto de cosas (físicas o abstractas) que tienen el mismo comportamiento y características. la jerarquía.

simplemente solicitamos determinadas acciones en espera de una respuesta. su cuerpo le responde comenzando a caminar. Pero la abstracción humana se gestiona de una manera jerárquica. por ejemplo. Los seres humanos no pensamos en las cosas como un conjunto de cosas menores. cuando una persona desea desplazarse. E. 3ULQFLSLR GH $EVWUDFFLyQ Mediante la abstracción la mente humana modeliza la realidad en forma de objetos. Esta es la forma de pensar que la orientación a objeto intenta cubrir. No necesitamos conocer los detalles de porqué ni cómo funcionan las cosas. no vemos un cuerpo humano como un conjunto de células. Los humanos entendemos la realidad como objetos con comportamientos bien definidos. Para ello busca parecidos entre la realidad y la posible implementación de REMHWRV GHO SURJUDPD que simulen el funcionamiento de los REMHWRV UHDOHV. para así entender más fácilmente la realidad. dividiendo sucesivamente sistemas complejos en conjuntos de subsistemas.

Para ello los objetos suelen presentar sus Página 17 de 189 . 3ULQFLSLR GH (QFDSVXODPLHQWR El encapsulamiento permite a los objetos elegir qué información es publicada y qué información es ocultada al resto de los objetos.

F.0. y en definitiva. Octubre de 1999 métodos como interfaces públicas y sus atributos como datos privados e inaccesibles desde otros objetos.Guía de iniciación al lenguaje Java. De esta manera el acceso a los datos de los objetos es controlado por el programador. Para permitir que otros objetos consulten o modifiquen los atributos de los objetos. olvidándose de cómo está implementada. evitando efectos laterales no deseados. Con el encapsulado de los datos se consigue que las personas que utilicen un objeto sólo tengan que comprender su interfaz. las clases suelen presentar métodos de acceso. reduciendo la complejidad de utilización. Versión 2.

además de facilitar la comprensión del programa. se propone al programador dividir su aplicación en varios módulos diferentes (ya sea en forma de clases. 3ULQFLSLR GH 0RGXODULGDG Mediante la modularidad. pues se afronta el problema como un conjunto de problemas de menor dificultad. paquetes o bibliotecas). G. cada uno de ellos con un sentido propio. Esta fragmentación disminuye el grado de dificultad del problema al que da respuesta el programa.

Así se simplifican los diseños y se evita la duplicación de código al no tener que volver a codificar métodos ya implementados. Por ejemplo.PDJHQ  (MHPSOR GH iUERO GH KHUHQFLD Mediante la KHUHQFLD una FODVH KLMD puede tomar determinadas propiedades de una FODVH SDGUH. H. y los mamíferos son animales.. un perro es un mamífero. y los animales seres vivos. La representación de dicha organización da lugar a los denominados iUEROHV GH KHUHQFLD: Clase Padre Clase Hija1 Clase Hija2 Clase Nieta1 Clase Nieta2 Clase Nieta3 . Del mismo modo. Al acto de tomar propiedades de una clase padre se denomina KHUHGDU. 3ULQFLSLR GH -HUDUTXtD La mayoría de nosotros ve de manera natural nuestro mundo como objetos que se relacionan entre sí de una manera jerárquica.. las distintas clases de un programa se organizan mediante la MHUDUTXtD.

El paso de mensajes se suele implementar como llamadas a los métodos de otros objetos. esto correspondería con la llamada a funciones. 3ULQFLSLR GHO 3DVR GH 0HQVDMHV Mediante el denominado SDVR GH PHQVDMHV. un objeto puede solicitar de otro objeto que realice una acción determinada o que modifique su estado. Página 18 de 189 . Desde el punto de vista de la programación estructurada.

Guía de iniciación al lenguaje Java. Versión 2. Octubre de 1999 I.0.

todo/parte.21(6 (175( 2%-(726 Durante la ejecución de un programa. ( 5(/$&. Por ejemplo un método puede presentar diferentes implementaciones en función de los argumentos que recibe. Esta propiedad permite que un objeto presente diferentes comportamientos en función del contexto en que se encuentre. 3ULQFLSLR GH 3ROLPRUILVPR Polimorfismo quiere decir "un objeto y muchas formas". los diversos objetos que lo componen han de interactuar entre sí para lograr una serie de objetivos comunes. Existen varios tipos de relaciones que pueden unir a los diferentes objetos. pero entre ellas destacan las relaciones de: asociación. D. y generalización/especialización. recibir diferentes números de parámetros para realizar una misma operación. y realizar diferentes acciones dependiendo del nivel de abstracción en que sea llamado.

Representan las relaciones con menos riqueza semántica. E. en las que un objeto realiza llamadas a los servicios (métodos) de otro. interactuando de esta forma con él. 5HODFLRQHV GH $VRFLDFLyQ Serían relaciones generales.

Esto se puede implementar como un objeto (REMHWR FRPSXHVWR) que cuenta entre sus atributos con otro objeto distinto (REMHWR FRPSRQHQWH). la agregación y la composición. F. En este tipo de relaciones un REMHWR FRPSRQHQWH se integra en un REMHWR FRPSXHVWR. 5HODFLRQHV GH 7RGR3DUWH Muchas veces una determinada entidad existe como conjunción de otras entidades. como un conglomerado de ellas. en la agregación no tiene por qué ser así. La orientación al objeto recoge este tipo de relaciones como dos conceptos. La diferencia entre agregación y composición es que mientras que la composición se entiende que dura durante toda la vida del objeto componedor.

lo que normalmente se abstrae en la creación de una tercera clase (SDGUH de las dos) que reúne todas sus características comunes. 5HODFLRQHV GH *HQHUDOL]DFLyQ(VSHFLDOL]DFLyQ A veces sucede que dos clases tiene muchas de sus partes en común. Página 19 de 189 . En realidad. propiedad por la que una clase (FODVH KLMD) recoge aquellos métodos y atributos que una segunda clase (FODVH SDGUH) ha especificado como "heredables". El ejemplo más extendido de este tipo de relaciones es la herencia. Este tipo de relaciones es característico de la programación orientada a objetos. mientras que la especialización es una perspectiva descendente (WRSGRZQ). la generalización es una perspectiva ascendente (ERWWRPXS). la generalización y la especialización son diferentes perspectivas del mismo concepto.

Versión 2.Guía de iniciación al lenguaje Java. Octubre de 1999 Para más información sobre el modelo de objetos en la programación avanzada. y las relaciones entre objetos véase >*DUFtD @ o para una información más detallada consulte >%RRFK @.0. Página 20 de 189 .

puede ocurrir cualquier cosa. creciendo hasta formar complicados procedimientos. No sólo se necesitaba un lenguaje de programación para tratar esta complejidad. y demás. paso de parámetros.Guía de iniciación al lenguaje Java. Java no tiene ninguna sentencia JRWR. El inadecuado uso de los punteros provoca la mayoría de los errores de colisión de memoria. un lenguaje capaz de interpretar dos estilos diferentes de programación. siendo todavía el programador. Este cambio de paradigma de la programación estructurada a la programación orientada a objetos. Java no tiene funciones PDOORF ni IUHH. Más tarde C++ añadió QHZ y GHOHWH. JRWR: Manera rápida de arreglar un programa sin estructurar el código. el responsable de liberar el espacio de memoria. Sin embargo Java tiene las sentencias EUHDN y FRQWLQXH que cubren los casos importantes de JRWR. que se usan de forma similar. errores muy difíciles de detectar. No es necesario utilizar un diseño orientado a objetos para programar en C++. El lenguaje C++ fue un intento de tomar estos principios y emplearlos dentro de las restricciones de C. La función IUHH devuelve un bloque asignado al sistema para que lo utilice. pero sólo considera las partes de C++ que no estaban ya en C. casi todos los virus que se han escrito aprovechan la capacidad de un programa para acceder a la memoria volátil (RAM) utilizando punteros. Variables globales: Con ellas cualquier función puede producir efectos laterales. Si se olvida de llamar a IUHH para liberar un bloque de memoria. asigna un número especificado de bytes de memoria devolviendo la dirección de ese bloque. Así Java utiliza convenciones casi idénticas para declaración de variables. comenzó hace 30 años con un lenguaje llamado Simula67. ralentizando progresivamente los programas. Esta compatibilidad ( KDFLD DWUiV ) que habitualmente se vende como una característica de C++ es precisamente su punto más débil.6(fÏ -$9$" Los lenguajes de programación C y Fortran se han utilizado para diseñar algunos de los sistemas más complejos en lenguajes de programación estructurada. razón por la que muchas veces las aplicaciones en este lenguaje no son realmente orientadas al objeto. De ahí provienen términos como “código de espagueti” o “canguros” referentes a programas con múltiples saltos y un control de flujo difícilmente trazable. evitando el acceso directo a la memoria volátil. Las principales características que Java no hereda de C++ son: Œ Punteros: Las direcciones de memoria son la característica más poderosa de C++. no existen punteros. En Java lo único global es el nombre de las clases. se están limitando los recursos del sistema. Œ Œ Œ Página 21 de 189 . perdiendo así los beneficios que este paradigma aporta.6725. e incluso se pueden producir fallos catastróficos cuando algún otro método cambia el estado de la variable global necesaria para la realización de otros procesos. Si por el contrario se hace un IUHH sobre un puntero ya liberado. Además. sino un nuevo estilo de programación.0. En Java. Todos los compiladores de C++ eran capaces de compilar programas de C sin clases. es decir.$ '( -$9$ $ ¢325 48e 6( '. Asignación de memoria: La función PDOORF de C. +. Octubre de 1999 . Versión 2.

de Sun Microsystems. Por ello en los sus ratos libres creó un lenguaje de programación donde intentaba solucionar los fallos que encontraba en C++. para dar margen de maniobra al equipo responsable del proyecto. Œ Conversión de tipos insegura: Los moldeados de tipo (W\SH FDVWLQJ) son un mecanismo poderoso de C y C++ que permite cambiar el tipo de un puntero. 2. Página 22 de 189 . Curiosamente. En Java se puede hacer una comprobación en tiempo de ejecución de la compatibilidad de tipos y emitir una excepción cuando falla.(1=26 Java fue diseñado en 1990 por James Gosling. Cuando no tenga ninguna referencia de ningún objeto.. Con QHZ no se obtiene una dirección de memoria sino un descriptor al objeto del PRQWtFXOR. Tras unos comienzos dudosos. pero sin tener que preocuparse de ello. % &20. aunque tuvo que cambiar de denominación. denominada FirstPerson Inc. como software para dispositivos electrónicos de consumo.0. Se dice este nombre se le puso debido a la existencia de tal árbol en los alrededores del lugar de trabajo de los promotores del lenguaje.Guía de iniciación al lenguaje Java. debido a que dicho nombre ya estaba registrado por otra empresa.PDJHQ  /RJRWLSR GH OD HPSUHVD 6XQ 0LFURV\VWHPV En los primeros años de la década de los noventa. Sun decidió crear una filial. La memoria real asignada a ese objeto se puede mover a la vez que el programa se ejecuta. Esto requiere extremada precaución puesto que no hay nada previsto para detectar si la conversión es correcta en tiempo de ejecución. Octubre de 1999 Se utiliza el operador QHZ para asignar un espacio de memoria a un objeto en el PRQWtFXOR de memoria. Versión 2. El recolector de basura se ejecuta siempre que el sistema esté libre. microondas y la televisión interactiva. Fiabilidad del código y facilidad de desarrollo. Sun Microsystems decidió intentar introducirse en el mercado de la electrónica de consumo y desarrollar programas para pequeños dispositivos electrónicos. . Inicialmente Java se llamó Oak (roble en inglés). la memoria ocupada estará disponible para que la reutilice el resto del sistema sin tener que llamar a IUHH o GHOHWH A esto se le llama UHFRJLGD GH EDVXUD. o cuando una asignación solicitada no encuentre asignación suficiente. todo este lenguaje fue diseñado antes de que diese comienzo la era World Wide Web. Gosling observó que muchas de las características que ofrecían C o C++ aumentaban de forma alarmante el gran coste de pruebas y depuración. puesto que fue diseñado para dispositivos electrónicos como calculadoras. Creciente necesidad de interfaces mucho más cómodas e intuitivas que los sistemas de ventanas que proliferaban hasta el momento. Tres de las principales razones que llevaron a crear Java son: 1.

Octubre de 1999 3. en lugar de tratar únicamente de optimizar las técnicas de desarrollo y dar por sentada la utilización de C o C++. & 35. Una vez que en Sun se dieron cuenta de que a corto plazo la televisión interactiva no iba a ser un gran éxito. Versión 2.(172 '( -$9$ Aunque muchas de las fuentes consultadas señalan que Java no llegó a caer en un olvido.0. Para más información véase >&XHQFD @. Basándose en el conocimiento y estudio de gran cantidad de lenguajes.Guía de iniciación al lenguaje Java. Para más información véase >)URXIH @ ' 5(685*. El sistema presentaba una interfaz basada en la representación de la casa de forma animada y el control se llevaba a cabo mediante una pantalla sensible al tacto. pero eliminando todas aquellas funciones que no eran absolutamente imprescindibles.PDJHQ  . pero fueron desarrollados enteramente en un Java primitivo. Por todo ello. el equipo de Gosling se planteó que tal vez los lenguajes existentes eran demasiado complicados como para conseguir reducir de forma apreciable la complejidad de desarrollo asociada a ese campo. Los dispositivos electrónicos se controlan mediante la utilización de microprocesadores de bajo precio y reducidas prestaciones. En el sistema aparecía ya 'XNH. Ninguno de estos proyectos se convirtió nunca en un sistema comercial. Enorme diversidad de controladores electrónicos. este grupo decidió recoger las características esenciales que debía tener un lenguaje de programación moderno y potente. la actual mascota de Java. Entre ellas se encontraba la aplicación de Java a Internet. la cual no se consideró productiva en ese momento. instaron a FirstPerson a desarrollar nuevas estrategias que produjeran beneficios.0. Por este motivo. lo cierto es que tuvo que ser Bill Joy (cofundador de Sun y uno de los Página 23 de 189 . su primera propuesta fue idear un nuevo lenguaje de programación lo más sencillo posible. Con este fin se construyó un ordenador experimental denominado *7 (Star Seven). y consistía en un sistema de control completo de los aparatos electrónicos y el entorno de un hogar. que varían cada poco tiempo y que utilizan diversos conjuntos de instrucciones.&Ï -$9$ El proyecto Green fue el primero en el que se aplicó Java.FRQR GH 'XNH OD PDVFRWD GH -DYD Más tarde Java se aplicó a otro proyecto denominado VOD (Video On Demand) en el que se empleaba como interfaz para la televisión interactiva que se pensaba iba a ser el principal campo de aplicación de Java. Java permite escribir un código común para todos los dispositivos. . con el objeto de que se pudiese adaptar con facilidad a cualquier entorno de ejecución.0(526 352<(&726 (1 48( 6( $3/.

por lo que el entorno necesario para su ejecución es de pequeño tamaño y puede adaptarse incluso al interior de un navegador. El problema fundamental de Java es que utiliza una representación intermedia denominada FyGLJR GH E\WH para solventar los problemas de portabilidad. Joy juzgó que Internet podría llegar a ser el campo adecuado para disputar a Microsoft su primacía en el terreno del software. ( )87852 '( -$9$ Existen muchas críticas a Java debido a su lenta velocidad de ejecución. La primera gran empresa que ha apostado por este tipo de máquinas ha sido Oracle. aunque sin duda potente. Sun está trabajando intensamente en crear versiones de Java con una velocidad mayor. Los FyGLJRV GH E\WH posteriormente se tendrán que transformar en código máquina en cada máquina en que son utilizados. Versión 2. que en enero de 1996 presentó en Japón su primer NC (Network Computer). WebPC o WebTop. Tras Página 24 de 189 . aproximadamente unas 20 veces más lento que un programa en lenguaje C. los datos del usuario quedan a salvo de la existencia de virus escritos en Java. siendo imposible que un programa escrito en Java pueda acceder a los recursos del ordenador sin que esta operación le sea permitida de forma explícita. basado en un procesador RISC con 8 Megabytes de RAM. Para más información véase >)URXIH @. La ejecución del código Java es segura y fiable: Los programas no acceden directamente a la memoria del ordenador. que no puede encontrarse en ninguna otra tecnología. De este modo. Algunas de las razones que llevaron a Bill Joy a pensar que Java podría llegar a ser rentable son: Œ Œ Œ Java es un lenguaje orientado a objetos: Esto es lo que facilita abordar la resolución de cualquier tipo de problema. La solución que se deriva de esto parece bastante obvia: fabricar ordenadores capaces de comprender directamente los códigos de byte. Éstas serían unas máquinas que utilizaran Java como sistema operativo y que no requerirían en principio de disco duro porque obtendrían sus recursos de la red. Es un lenguaje sencillo.0. La ejecución segura y controlada del código Java es una característica única. Es totalmente multiplataforma: Es un lenguaje sencillo. lo que ralentiza considerablemente el proceso de ejecución. Para poder presentarlo en sociedad se tuvo que modificar el nombre de este lenguaje de programación y se tuvo que realizar una serie de modificaciones de diseño para poderlo adaptar al propósito mencionado. Œ Las consecuencias de la utilización de Java junto a la expansión universal de Internet todavía están comenzando a vislumbrarse. Octubre de 1999 desarrolladores principales del sistema operativo Unix de Berckley) el que sacó a Java del letargo en que estaba sumido. Así Java fue presentado en sociedad en agosto de 1995.Guía de iniciación al lenguaje Java. y vio en Oak el instrumento idóneo para llevar a cabo estos planes. A los ordenadores que utilizan Java como sistema operativo se les llama Network Computer.

) (63(&8/$&. Octubre de 1999 Oracle.. lo ha incluido en Internet Explorer (versión 3. Java es una plataforma que le falta madurar. y ha lanzado un entorno de desarrollo para Java. elementos de conectividad. Microsoft. que en los comienzos de Java no estaba a favor de su utilización. bibliotecas. Por otra parte. pero que a buen seguro lo va a hacer. sino de Internet.0 y posteriores). han sido compañías del tamaño de Sun. La apuesta realizada por empresas con mucho peso específico ha sido tan grande que va a dar un impulso a Java que no le permitirá caer Además. que se denomina Visual J++.0. ha licenciado Java. el parque de productos (entornos de desarrollo. La principal empresa en el mundo del software.Ï1 62%5( (/ )87852 '( -$9$ En opinión de los redactores de este tutorial.. Para más información véase >)UDPLxiQ @. Apple e IBM las que han anunciado desarrollos similares. Versión 2. Sun va a apostar por firmas digitales.) ya disponible en la actualidad es tan amplio que es improbable que se quede en nada. la relación simbiótica que tiene con Internet (y por derivación con las Intranets) es un punto a favor de Java de muy difícil refutación. que serán clave en el desarrollo no sólo de Java. Página 25 de 189 .Guía de iniciación al lenguaje Java. El único problema aparente es la seguridad para que Java se pueda utilizar para transacciones críticas.

Proporciona un conjunto de clases potente y flexible. Pone al alcance de cualquiera la utilización de aplicaciones que se pueden incluir directamente en páginas Web (aplicaciones denominadas DSSOHWV) Java aporta a la Web una interactividad que se había buscado durante mucho tiempo entre usuario y aplicación.Guía de iniciación al lenguaje Java. y esto viene avalado por tres elementos claves que diferencian a este lenguaje desde un punto de vista tecnológico: Œ Œ Œ Es un lenguaje de programación que ofrece la potencia del diseño orientado a objetos con una sintaxis fácilmente accesible y un entorno robusto y agradable. Octubre de 1999 . A lo largo de este apartado se estudian en detalle las principales características de Java.Ï1 No es arriesgado afirmar que Java supone un significativo avance en el mundo de los entornos software. Versión 2. &$5$&7(5Ë67.1752'8&&.0. % 327(17( D.&$6 '( -$9$ $ .

Además se conservan elementos “no objetos”. caracteres y otros tipos de datos simples. En Java el concepto de objeto resulta sencillo y fácil de ampliar. no siendo derivado de otro lenguaje anterior y no tiene compatibilidad con ninguno de ellos. E. como números. 2ULHQWDFLyQ D REMHWRV En este aspecto Java fue diseñado partiendo de cero.

se ha conseguido un gran potencial de expresión e innovación desde el punto de vista del programador. F. y aunque cada tarea se puede realizar de un número reducido de formas. 5LTXH]D VHPiQWLFD Pese a su simpleza se ha conseguido un considerable potencial.

Estos elementos realizarán muchas tareas antes tediosas a la vez que obligadas para el programador. 5REXVWR Java verifica su código al mismo tiempo que lo escribe. Se realiza un descubrimiento de la mayor parte de los errores durante el tiempo de compilación. Este lenguaje posee una gestión avanzada de memoria llamada gestión de basura. y una vez más antes de ejecutarse. de manera que se consigue un alto margen de codificación sin errores. ya que Java es estricto en cuanto a tipos y declaraciones. Respecto a la gestión de memoria. y un manejo de excepciones orientado a objetos integrados. Página 26 de 189 . y así lo que es rigidez y falta de flexibilidad se convierte en eficacia. Java libera al programador del compromiso de tener que controlar especialmente la asignación que de ésta hace a sus necesidades específicas.

Versión 2.0.Guía de iniciación al lenguaje Java. Octubre de 1999 G.

Estos paquetes implementan componentes de una interfaz de usuario gráfica básica común a todos los ordenadores personales modernos. El conjunto de clases más complicado de Java son sus paquetes gráficos AWT ($EVWUDFW :LQGRZ 7RRONLW) y 6ZLQJ. 0RGHOR GH REMHWR ULFR Existen varias clases que contienen las abstracciones básicas para facilitar a los programas una gran capacidad de representación. & 6.03/( D. Para ello se contará con un conjunto de clases comunes que pueden crecer para admitir todas las necesidades del programador. Además la biblioteca de clases de Java proporciona un conjunto único de protocolos de Internet.

El único obstáculo que se puede presentar es conseguir comprender la programación orientada a objetos. pero más sencillo que cualquier otro entorno de programación. al ser independiente del lenguaje. se presenta como insalvable. )iFLO DSUHQGL]DMH El único requerimiento para aprender Java es tener una comprensión de los conceptos básicos de la programación orientada a objetos. aspecto que. E. Java es más complejo que un lenguaje simple. Así se ha creado un lenguaje simple (aunque eficaz y expresivo) pudiendo mostrarse cualquier planteamiento por parte del programador sin que las interioridades del sistema subyacente sean desveladas.

El JDK (-DYD 'HYHORSPHQW . como clases ya implementadas.LW. Existirá una interfaz 2EVHUYHU2EVHUYDEOH que permitirá la implementación simple de objetos dinámicos cuyo estado se visualiza en pantalla. &RPSOHWDGR FRQ XWLOLGDGHV El paquete de utilidades de Java viene con un conjunto completo de estructuras de datos complejas y sus métodos asociados. Se dispone también de estructuras de datos habituales. que serán de inestimable ayuda para implementar DSSOHWV y otras aplicaciones más complejas. como SLODV y WDEODV KDVK.

(17$'2 $ 5(' D. ' .17(5$&7. un depurador en línea de comandos. y un visualizador de DSSOHWV entre otros elementos. un intérprete de aplicaciones.92 < 25. suministrado por Sun Microsystems incluye un compilador.

Página 27 de 189 . Para se da soporte a la utilización de múltiples hilos de programación (PXOWLWKUHDG). y éstas pueden concebirse con logotipos animados o con texto que se desplace por la pantalla. .QWHUDFWLYR \ DQLPDGR Uno de los requisitos de Java desde sus inicios fue la posibilidad de crear programas en red interactivos. Las aplicaciones de Java permiten situar figuras animadas en las páginas Web. por lo que es capaz de hacer varias cosas a la vez sin perder rastro de lo que debería suceder y cuándo.

Versión 2.0. Octubre de 1999 También pueden tratarse gráficos generados por algún proceso. E. Estas animaciones pueden ser interactivas. permitiendo al usuario un control sobre su apariencia.Guía de iniciación al lenguaje Java.

$UTXLWHFWXUD QHXWUDO Java está diseñado para que un programa escrito en este lenguaje sea ejecutado correctamente independientemente de la plataforma en la que se esté actuando (Macintosh. el hecho de que Java fuese diseñado para funcionar razonablemente bien en microprocesadores de escasa potencia. La desventaja de un sistema de este tipo es el rendimiento. que pueden interpretarse en cualquier sistema operativo con un intérprete de Java. PC. Para conseguir esto utiliza una compilación en una representación intermedia que recibe el nombre de FyGLJRV GH E\WH. F. sin embargo. UNIX…). unido a la sencillez de traducción a código máquina hacen que Java supere esa desventaja sin problemas.

El envío de las clases de Java a través de Internet se realiza con gran facilidad. NNTP y SMTP junto con conectores de red de bajo nivel e interfaces de nombrado. Este lenguaje está diseñado para cumplir los requisitos de entrega de contenidos interactivos mediante el uso de applets insertados en sus páginas HTML. el contenido ejecutable es transferido literalmente al ordenador del usuario. Java proporciona un conjunto de clases para tratar con una abstracción de los conectores de red (VRFNHWV. Esto le permite interactuar con esos servicios de red poderosos sin tener que comprender realmente los detalles de bajo nivel de esos protocolos. resolviendo así los típicos problemas de diferencia de versiones. HTTP. Se incluyen implementaciones ampliables de los protocolos FTP. Los protocolos básicos para trabajar en Internet están encapsulados en unas cuantas clases simples. de manera que los suministradores de información de la Web pueden crear una página de hipertexto (SiJLQD :HE) con una interacción continuada y compleja en tiempo real. 7UDEDMR HQ UHG Java anima las páginas Web y hace posible la incorporación de aplicaciones interactivas y especializadas. ya que existe una interfaz unificada. Aporta la posibilidad de distribuir contenidos ejecutables. las clases de Java admiten muy bien estos protocolos y formatos. Además.

originales de la versión UNIX de Berckley. G. encapsular la noción de una dirección de Internet o conectar sockets con flujos de datos de Entrada/Salida. Con todas estas posibilidades aumenta el dinamismo y competitividad de la Web. puesto que es capaz de captar el interés del usuario durante largo tiempo y permite a los programadores convertir la Web en un sistema de entrega de software.

la verdadera novedad es el gran potencial que Java proporciona en este aspecto. haciendo posible que los programadores ejerzan un control sobre los programas ejecutables de Java que no es posible encontrar en otros lenguajes. Sin embargo. pudiendo reaccionar a la entrada de un usuario y cambiar de forma dinámica. $SSOHWV Una DSSOHW (miniaplicación) es un pequeño programa en Java transferido dinámicamente a través de Internet. Página 28 de 189 . Presentan un comportamiento inteligente.

Octubre de 1999 ( < 08&+2 0È6 D.0. Versión 2.Guía de iniciación al lenguaje Java.

E. Verificación del nombre de clase y de restricciones de acceso durante la carga. 6HJXULGDG Existe una preocupación lógica en Internet por el tema de la seguridad: virus. como son la eliminación de punteros aritméticos y de operadores ilegales de transmisión. y programas similares navegan de forma usual por la red. Sistema de seguridad de la interfaz que refuerza las medidas de seguridad en muchos niveles. Java ha sido diseñado poniendo un énfasis especial en el tema de la seguridad. caballos de Troya. constituyendo una amenaza palpable. y se ha conseguido lograr cierta inmunidad en el aspecto de que un programa realizado en Java no puede realizar llamadas a funciones globales ni acceder a recursos arbitrarios del sistema. Rutina de verificación de los FyGLJRV GH E\WH que asegura que no se viole ninguna construcción del lenguaje. Los niveles de seguridad que presenta son: Œ Œ Œ Œ Fuertes restricciones al acceso a memoria. por lo que el control sobre los programas ejecutables no es equiparable a otros lenguajes. En futuras versiones se prevé contar también con encriptación y técnicas similares.

Básicamente. /HQJXDMH EDVDGR HQ & Java fue desarrollado basándose en C++. F. No soporta herencia múltiple. Java cuenta con un sistema automático para asignar y liberar memoria. Java maneja argumentos en la línea de comandos de forma diversa a como lo hacen C o C++. encontramos las siguientes diferencias con C++: Œ Œ Œ Œ Œ Œ Œ Java no soporta los tipos VWUXFW XQLRQ ni punteros No soporta W\SHGHI ni GHILQH Se distingue por su forma de manejar ciertos operadores y no permite una sobrecarga de operadores. Tiene una clase 6WULQJ que es parte del paquete MDYDODQJ y se diferencia de la matriz de caracteres terminada con un nulo que usan C y C++. pero eliminando rasgos del mismo poco empleados. optándose por una codificación comprensible. con lo que no es necesario utilizar las funciones previstas con este fin en C y C++.

se utlizan primitivas similares a las de C++. que permiten tratar los ficheros. *HVWLyQ GH OD (QWUDGD6DOLGD En lugar de utilizar primitivas como las de C para trabajar con ficheros. mucho más elegantes. sockets. Página 29 de 189 . teclado y monitor como flujos de datos.

Guía de iniciación al lenguaje Java.0. Octubre de 1999 De este modo se pueden utilizar dichas primitivas para cualquier operación de Entrada/Salida. Versión 2. G.

que se puedan incorporar gráficamente a otros componentes. 'LIHUHQWHV WLSRV GH DSOLFDFLRQHV En Java podemos crear los siguientes tipos de aplicaciones: Œ Œ Œ Œ Œ Aplicaciones: Se ejecutan sin necesidad de un navegador. -DYD%HDQV: Componentes software Java. Página 30 de 189 . $SSOHWV: Se pueden descargar de Internet y se observan en un navegador. -DYD6FULSW: Conjunto del lenguaje Java que puede codificarse directamente sobre cualquier documento HTML 6HUYOHWV: Módulos que permiten sustituir o utilizar el lenguaje Java en lugar de programas CGI (Common Gateway Interface) a la hora de dotar de interactividad a las páginas Web.

9$ &21 27526 /(1*8$-(6 '( 352*5$0$&.Guía de iniciación al lenguaje Java.326 '( '$726 D. Versión 2. debía ser fiable y fácil de desarrollar y los programas debían ser portables de un sistema a otro sin ningún tipo de problema.(17$'26 $ 2%-(72 $ . En principio Java fue diseñado tomando C y C++ como base para la creación de un nuevo lenguaje con la modificación de todos aquellos aspectos que no eran útiles o dificultosos para la programación de componentes electrónicos de bajo coste. &203$5$7.Ï1 En este apartado se va a comparar Java con otros lenguajes de programación orientados a objeto. Para ello el nuevo lenguaje debía incluir interfaces cómodas. Octubre de 1999 . % &203$5$&.0.1752'8&&.Ï1 '( /26 7.Ï1 25.

7LSRV GH GDWRV VLPSOHV SULPLWLYRV.

Java es muy parecido a C++ en el juego básico de tipos de datos con algunas pequeñas modificaciones. Los tipos de datos primitivos (o simples) pueden ser numéricos. booleanos o caracteres. En Java se distingue entre tipos de datos primitivos y clases. aunque existen unas clases especiales (HQYROWRULRV o ZUDSSHUV) que permiten modificar los tipos de datos primitivos. E.

y los ORQJ de 8 bytes. VKRUW de 2 bytes. El tipo más habitual de los cuatro es el tipo LQW. ya que Java introduce una interpretación diferente al tipo de datos FKDU Las principales diferencias con C++ son: Œ Œ Œ No existe un tipo sin signo (XQVLJQHG. El E\WH viene a sustituir el tipo FKDU de C++. LQW de 4 bytes. 'DWRV QXPpULFRV Hay cuatro tipos numéricos: E\WH de 1 byte.

Los tipos numéricos reales son el IORDW  bytes) y el GRXEOH (16 bytes). F.96) son considerados GRXEOH por defecto. y habrá que realiza un moldeado (FDVWLQJ) explícito para que sean IORDW. Los números que utilizan coma flotante (por ejemplo 18. para los números en Java.

Hay que señalar que los caracteres en C++ eran de sólo 1 byte. Los caracteres son 8QLFRGH de 2 bytes. que son suficientes para las los diferentes lenguajes y sistemas de representación del planeta. Página 31 de 189 . Los caracteres 8QLFRGH son valores de 2 bytes sin signo. &DUDFWHUHV Los datos carácter en Java se basan en los de C++ que a su vez son heredados de C. con lo que se define obtiene un rango de 65535 caracteres diferentes. con lo que en Java podremos representar muchos más caracteres que en C++. El carácter de datos del lenguaje Java proviene del tradicional C.

Guía de iniciación al lenguaje Java. Versión 2.0. Octubre de 1999 G

'DWRV ERROHDQRV

En Java se definen para las variables con valores Verdadero/Falso o Sí/No, en definitiva, valores bi-estado. Una variable booleana puede tener los valores WUXH verdadero) o IDOVH falso). Son parecidos a los de C++, aunque en cualquier caso, y a diferencia de C++ estas variables no pueden ser convertidas a datos numéricos, y es un tipo de datos básico.
& 23(5$'25(6 5(/$&,21$/(6 < $5,70e7,&26

Se permite en Java los mismos operadores que C++, con la variación de !!! (desplazamiento sin signo) y la utilización del operador  para la concatenación de cadenas de caracteres.
' 9(&725(6

Los vectores en Java, a diferencia de C++, son una clase de objetos. Un vector es un objeto real con una representación en tiempo real. Se pueden declarar y almacenar vectores de cualquier tipo, y almacenar también vectores de vectores para obtener matrices (vectores con varias dimensiones). En este último aspecto no existe diferencia con C++.
( &$'(1$6

Las cadenas en Java son objetos del lenguaje, no existen seudo-arrays de caracteres (cadenas) como era el caso de C++. Existen dos tipos de cadenas de objetos: Las que se obtienen de la clase 6WULQJ, para cadenas de sólo lectura. Las que se obtienen de la clase 6WULQJ%XIIHU para cadenas que se pueden modificar. Al igual que C++, el compilador de Java entiende que una cadena de caracteres rodeada de dobles comillas es una cadena, y es iniciada como un objeto de tipo 6WULQJ (en C++ sería como vector de caracteres con el carácter fin de cadena ‘\0’ al final de la misma).
) 275$6 &$5$&7(5Ë67,&$6
D

,QWURGXFFLyQ

En este apartado se va a comparar Java con los lenguajes C++ y Smalltalk (primer lenguaje que presentaba un modelo de objeto). &DUDFWHUtVWLFD Sencillez Robustez Seguridad Interpretado Dinamicidad Portabilidad -DYD Sí Sí Sí Sí Sí Sí 6PDOOWDON & Sí No Sí Algo Sí Sí Algo No No No No No

Página 32 de 189

Guía de iniciación al lenguaje Java. Versión 2.0. Octubre de 1999

Neutralidad Threads Garbage Colection Excepciones Representación

Sí Sí Sí Sí Alta

Algo No Sí Sí Media

No No No Algunas Alta

7DEOD  &RPSDUDFLyQ HQWUH -DYD 6PDOO7DON \ &
E

Desaparecen los registros (VWUXFW). Ya no es necesario liberar memoria (IUHH R GHOHWH). 6HQFLOOH] Java tiene una sencillez que no posee C++ aunque sí Smalltalk. No se permite ni la definición de tipos (W\SHGHI) ni la de macros ( GHILQH). F. y la utilización de un intérprete bastante pequeño. es la eliminación de palabras reservadas. algo que se logra con mucho éxito puesto que Java reduce un 50% los errores que se comenten en C++ entre los que destacan: Œ Œ Œ Œ Eliminación de la aritmética de punteros y de las UHIHUHQFLDV. De todas formas. lo que Java hace. en realidad. heredados del paradigma estructurado. Esto es debido a que una de las razones de la creación de Java es la de obtener un lenguaje parecido a C++ pero reduciendo los errores más comunes de la programación.

Gestión de excepciones y errores. Algunas de estas verificaciones que hacen que Java sea un lenguaje robusto son: Œ Œ Œ Verificación del FyGLJR GH E\WH. G. Comprobación de punteros y de límites de vectores. Se aprecia una clara diferencia con C++ quién no realiza ninguna de estas verificaciones. normalmente en el ciclo de desarrollo. lo que hace que se detecten errores lo antes posible. 5REXVWH] Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en tiempo de ejecución.

6HJXULGDG En Java no se permite los accesos ilegales a memoria. El código Java pasa muchos tests antes de ejecutarse en una máquina. El código se pasa a través de un verificador de FyGLJR GH E\WH que comprueba el formato de los fragmentos de código y aplica un probador de teoremas para detectar fragmentos de código ilegal. algo que sí se permitía en C++. código que falsea punteros. Algunos de los conocimientos que podemos obtener de los códigos de byte si pasan la verificación sin generar ningún mensaje de error son: Página 33 de 189 . viola derechos de acceso sobre objetos o intenta cambiar el tipo o clase de un objeto. Esto es algo muy importante puesto que este tipo de problema puede ocasionar la propagación de virus y otras clases de programas dañinos por la red.

SULYDWH y SURWHFWHG. por lo que Java es el único de los tres considerable como seguro. la obligación de autentificación por clave pública para la realización de modificaciones. No ha ocurrido ninguna conversión ilegal de datos. El tipo de los parámetros de todos los códigos de operación es conocido y correcto. El acceso a los campos de un objeto se sabe si es legal mediante las palabras reservadas SXEOLF. No hay ningún intento de violar las reglas de acceso y seguridad establecidas. H. Versión 2. Octubre de 1999 Œ Œ Œ Œ Œ El código no produce desbordamiento de operandos en la pila. se considera Java un lenguaje seguro. y por no permitirlo mediante Java la utilización de métodos de un programa sin los privilegios del núcleo (NHUQHO) del sistema operativo. tal como convertir enteros en punteros.0. Por todo esto.Guía de iniciación al lenguaje Java. Todo esto no lo incorporan ni C++ ni Smalltalk.

Esto es una característica que sí que posee Smalltalk. el actual compilador que existe es bastante lento. aunque no C++. /HQJXDMH LQWHUSUHWDGR Java es un lenguaje que puede ejecutar el código directamente. y aunque en teoría se consumen menos recursos siendo los lenguajes interpretados. No obstante. Esto normalmente no es vital para la aplicación ni demasiado apreciable por el usuario. es decir es un “lenguaje interpretado”. y además esta diferencia se está reduciendo con los nuevos compiladores JIT (-XVW .Q 7LPH. unas 20 veces menos rápido que C++.

 I.

Esta característica ya es contemplada por Smalltalk. que enlaza todos los módulos cuando se compila. 'LQDPLFLGDG Para la obtención de un mayor provecho de la tecnología orientada a objetos. J. aunque no C++. Java no intenta conectar todos los módulos que comprenden una aplicación hasta el tiempo de ejecución.

3RUWDELOLGDG Un programa Java puede ser ejecutado en diferentes entornos. algo imposible para C++. K.

x. Windows 95. Cualquier máquina que tenga el sistema de ejecución (-5( o -DYD 5XQWLPH (QYLURPHQW) puede ejecutar ese código objeto. Apple y probablemente haya grupos de desarrollo trabajando el portado a otras plataformas. Irix. 1HXWUDOLGDG Se dice que Java tiene una arquitectura neutra puesto que compila su código a un fichero objeto de formato independiente de la arquitectura de la máquina en que se ejecutará.1. donde el código generado podrá ejecutarse únicamente en la plataforma en la que se generó. Windows NT. sin importar en modo alguno la máquina en que ha sido generado.x. Linux. Página 34 de 189 . Aix. Actualmente existen sistemas de ejecución (-5() para Solaris 2. SunOs 4. No es así para C++ y para Smalltalk. Mac.

Octubre de 1999 L.0.Guía de iniciación al lenguaje Java. Versión 2.

M. La posibilidad de construir pequeños procesos o piezas independientes de un gran proceso permite programar de una forma más sencilla y es una herramienta muy potente que no se ofrece en C++. 7KUHDGV Java permite múltiples hilos (PXOWLWKUHDGLQJ) antes de su ejecución y en tiempo de ejecución.

5HFROHFFLyQ DXWRPiWLFD GH EDVXUD *DUEDJH FROHFWLRQ .

La recolección de basura (objetos ya inservibles) es una parte integral de Java durante la ejecución de sus programas. GHOHWH. QHZ. el sistema hace un seguimiento del estado del objeto. Java modifica completamente la gestión de la memoria que se hace en C/C++. el sistema vacía ese espacio de memoria para un uso futuro. IUHH. Java tiene operadores nuevos para reservar memoria para los objetos. pero no existe ninguna función explícita para liberarla.. reservas de memoria (con las ordenes PDOORF. Una vez que se ha almacenado un objeto en el tiempo de ejecución.. En C/C++ se utilizan punteros. N. y en el momento en que se detecta que no se va a volver a utilizar ese objeto.) y otra serie de elementos que dan lugar a graves errores en tiempo de ejecución difícilmente depurables. Esta gestión de la memoria dinámica hace que la programación en Java sea más fácil.

Página 35 de 189 . y en ningún caso con interfaces portables como los que Java crea. aunque con unos métodos más costosos. Esto también se permite en C++. Tanto en Java como en C++ se logran unas interfaces con una representación mejor que la que se puede alcanzar con Smalltalk. 5HSUHVHQWDFLyQ Uno de los objetivos perseguidos en el desarrollo de Java era la obtención de programas con interfaces cómodas e intuitivas.

 )81'$0(1726 '(/ /(1*8$-( Página 36 de 189 .Guía de iniciación al lenguaje Java.. Octubre de 1999 7(0$ .0. Versión 2.

Versión 2. palabras clave. que abstrae las diferencias entre procesadores a un procesador virtual único. operadores y separadores. )81'$0(1726 $ .1752'8&&. D. el compilador analiza el texto.. reconoce y elimina los espacios en blanco y comentarios y extrae WRNHQV individuales. constantes. Los códigos de byte se ajustan al sistema de máquina virtual Java.Ï1 Java es un lenguaje orientado a objetos. Cuando se compila un programa Java. que se deriva en alto grado de C++. que es independiente del sistema e interpretable dentro de un entorno Java. de tal forma que puede ser considerado como un C++ nuevo y modernizado o bien como un C++ al que se le han amputado elementos heredados del lenguaje estructurado C. % 72.Guía de iniciación al lenguaje Java. Los WRNHQV resultantes se compilan. traduciéndolos a código de byte Java. Los WRNHQV Java pueden subdividirse en cinco categorías: Identificadores. Estos WRNHQV definen la estructura de Java. Octubre de 1999 .0.(16 Un WRNHQ es el elemento más pequeño de un programa que es significativo para el compilador.

Además de las restricciones mencionadas existen propuestas de estilo.QWHUID]. Como nombres de identificadores no se pueden usar palabras claves de Java.QWHUID] o 0L.GHQWLILFDGRUHV Los identificadores son WRNHQV que representan nombres asignables a variables. métodos y clases para identificarlos de forma única ante el compilador y darles nombres con sentido para el programador. Los métodos: PHWRGR . . Los caracteres posteriores del identificador pueden incluir las cifras del 0 al 9. Todos los identificadores de Java diferencian entre mayúsculas y minúsculas (Java es &DVH 6HQVLWLYH o 6HQVLEOH D PD\~VFXODV) y deben comenzar con una letra. Las interfaces: . un subrayado(_) o símbolo de dólar($). Es una práctica estándar de Java denominar: Œ Œ Œ Œ Œ Œ Las clases: &ODVH o 0L&ODVH.

o PHWRGR/DUJR .

Sin entrar en más detalle en la siguiente línea de código se puede apreciar la declaración de una variable entera (LQW) con su correspondiente identificador: int alturaMedia. Página 37 de 189 . Los paquetes: MDYDSDTXHWHVXESDTXHWH. Las variables: DOWXUD o DOWXUD0HGLD. Las constantes: &2167$7( o &2167$17(B/$5*$.

0.Guía de iniciación al lenguaje Java. Octubre de 1999 E. Versión 2.

asegúrese de que presta atención a las palabras clave de Java. La definición de estas palabras clave no se ha revelado. Java tiene un conjunto de palabras clave más rico que C o que C++. F. ni se tiene un calendario respecto a cuándo estará alguna de ellas en la especificación o en alguna de las implementaciones de Java. por lo que sí está aprendiendo Java con conocimientos de C o C++. 3DODEUDV FODYH Las palabras claves son aquellos identificadores reservados por Java para un objetivo determinado y se usan sólo de la forma limitada y específica. Las siguientes palabras son palabras reservadas de Java: DEVWDFW FDVH FRQVW HOVH IORDW LI LQW QXOO SURWHFWHG VWDWLF WKURZ YDU ERROHDQ EUHDN E\WH FDVW FDWFK FKDU FRQWLQXH GHIDXOW GR H[WHQGV IDOVH ILQDO IRU IXWXUH JHQHULF LPSOHPHQWV LPSRUW LQQHU LQWHUIDFH ORQJ QDWLYH RSHUDWRU RXWHU SDFNDJH SXEOLF UHVW UHWXUQ VXSHU VZLWFK V\QFURQLFHG WKURZV WUDQVLHQW WUXH YRLG YRODWLOH ZKLOH 7DEOD  3DODEUDV UHVHUYDGDV -DYD E\YDOXH FODVV GRXEOH ILQDOO\ JRWR LQVWDQFHRI QHZ SULYDWH VKRUW WKLV WU\ Las palabras subrayadas son palabras reservadas pero no se utilizan.

Cada variables es de un tipo de datos concreto. y dichos tipos de datos tienen sus propios literales. booleanas. Las cadenas. Se puede observar que utilizamos ILQDO VWDWLF. para que la variable sea total y absolutamente invariable. Mediante determinados modificadores (VWDWLF y ILQDO) podremos crear variables FRQVWDQWHV. aún se consideran constantes. Las constantes pueden ser numéricas. que no modifican su valor durante la ejecución de un programa. caracteres (Unicode) o cadenas (6WULQJ). aunque están implementadas en Java como objetos. Veamos un ejemplo de constante declarada por el usuario: final static int ALTURA_MAXIMA = 200. que contienen múltiples caracteres. G. /LWHUDOHV \ FRQVWDQWHV Los literales son sintaxis para asignar valores a las variables.

indican una evaluación o computación para ser realizada en objetos o datos. y en definitiva sobre identificadores o constantes. Los operadores admitidos por Java son:  !!! !! A      a > A  !  @   __ Página 38 de 189 . 2SHUDGRUHV Conocidos también como operandos.

0. Versión 2.Guía de iniciación al lenguaje Java. Octubre de 1999 ! !!!  "  7DEOD  2SHUDGRUHV -DYD .

las expresiones son utilizadas para realizar cálculos. y estudiaremos el significado de cada uno de estos operadores. que se agrupan para crear VHQWHQFLDV. Los separadores admitidos por Java son: ^ `    I &RPHQWDULRV \ HVSDFLRV HQ EODQFR El compilador de Java reconoce y elimina los espacios en blanco. Los comentarios se pueden presentar en tres formatos distintos: )RUPDWR /*comentario*/ //comentario /**comentario*/ 8VR Se ignoran todos los caracteres entre /* */. operadores y llamadas a métodos (construida conforme a la sintaxis del lenguaje) que se evalúa a un único valor. variables y las llamadas a métodos pueden ser combinadas en secuencias conocidas como expresiones.. por lo que el uso de un operador es una expresión. y para ayudar a controlar la ejecución del flujo del programa. Una expresión es una serie de variables. retornos de carro y comentarios durante el análisis del código fuente. !! _ Así por ejemplo el siguiente fragmento de código incrementa el valor de una variable en dos unidades. // No menos de 150 centímetros & (. la siguiente sentencia es una expresión: int contador=1. miNumero = miNumero + 2. Entre otras cosas. Los operadores devuelven un valor. para asignar valores a variables. Página 39 de 189 . mediante la utilización del operador aritmético  que se utiliza para la suma: int miNumero=0.35(6. 2SHUDGRUHV de este tutorial aprenderemos que en Java hay formas más sencillas de hacer esto mismo. 7DEOD  )RUPDWRV GH FRPHQWDULRV -DYD Por ejemplo la siguiente línea de código presenta un comentario: int alturaMinima = 150. Por ejemplo. En el apartado . Proviene del C++ Lo mismo que /* */ pero se podrán utilizar para documentación automática. El comportamiento real de un programa Java se logra a través de expresiones. H 6HSDUDGRUHV Se usan para informar al compilador de Java de cómo están agrupadas las cosas en el código. La tarea de una expresión se compone de dos partes: realiza el cálculo indicado por los elementos de la expresión y devuelve el valor obtenido como resultado del cálculo. Proviene del C Se ignoran todos los caracteres detrás de // hasta el fin de línea. tabuladores.21(6 Los operadores.

.read( ) != -1 // in es un flujo de entrada Esta sentencia se compone de dos expresiones: 1.0.Guía de iniciación al lenguaje Java. El tipo de datos del valor devuelto por una expresión depende de los elementos utilizados en la expresión. cadenas. La expresión FRQWDGRU en este caso particular se evalúa al valor . La expresión FRQWDGRU devuelve un entero porque  devuelve un valor del mismo tipo que su operando y FRQWDGRU es un entero.. pero la variable FRQWDGRU adquiere un valor de . La primera expresión es una llamada al método LQUHDG . Otra sentencia interesante sería: in. que era el valor de la variable FRQWDGRU antes de que la operación ocurra. Otras expresiones devuelven valores booleanos. Octubre de 1999 contador++. Versión 2. Una expresión de llamada a un método se evalúa al valor de retorno del método. así el tipo de dato de la expresión de llamada a un método es el mismo que el tipo de dato del valor de retorno de ese método.

 El método LQUHDG .

ha sido declarado para devolver un entero. por lo que la expresión LQUHDG .

En la sentencia en cuestión. los operandos son LQUHDG . La segunda expresión contenida en la sentencia utiliza el operador . que comprueba si dos operandos son distintos. se evalúa a un entero. 2.

El operando LQUHDG . y -1.

es válido para el operador porque iQUHDG .

es una expresión que se evalúa a un entero. así que la expresión LQUHDG .

72 En Java el código fuente está dividido en partes separadas por llaves. Esto tiene explicación si entendemos que existe una MHUDUTXtD GH EORTXHV. que viene determinado por los bloques. denominas EORTXHV. en el que es usada. Toda variable tiene un ámbito. Desde un bloque externo parece que todo lo que está dentro de llaves se ejecuta como una sentencia. Página 40 de 189 . Java permite construir sentencias (expresiones compuestas) a partir de varias expresiones más pequeñas con tal que los tipos de datos requeridos por una parte de la expresión concuerden con los tipos de datos de la otra. Las llaves de separación son importantes no sólo en un sentido lógico. Cada bloque existe independiente de lo que está fuera de él. El ámbito se refiere a cómo las secciones de un programa (bloques) afectan el tiempo de vida de las variables. ¿qué es un bloque externo?. Pero. sino que tienen una connotación estética que facilita la lectura de los programas al ser humano. agrupando en su interior sentencias (expresiones) relacionadas. El valor devuelto por esta expresión será verdadero o falso dependiendo del resultado de la lectura del fichero LQ. Como se puede observar. Una variable definida en un bloque interno no es visible por el bloque externo. ya que son la forma de que el compilador diferencie dónde acaba una sección de código y dónde comienza otra. El concepto de ámbito está estrechamente relacionado con el concepto de bloque y es muy importante cuando se trabaja con variables en Java.  compara dos enteros. y que un bloque puede contener uno o más subbloques anidados. ' %/248(6 < È0%.

Las sangrías se utilizan para el programador. // Da error: Y fuera de ambito } Página 41 de 189 .Guía de iniciación al lenguaje Java. { // Bloque interno invisible al exterior int y = 2. La sangría (también denominada LQGHQWDFLyQ) más adecuada para la estética de un programa Java son dos espacios: { // Bloque externo int x = 1. Versión 2. Octubre de 1999 Así mismo. } x = y.0. para identificar los diferentes bloques se utilizan sangrías. no para el compilador.

las matrices y tanto las clases como las interfaces. de coma flotante. booleanos y de carácter. Versión 2. Octubre de 1999 .GHQWLILFDGRU Los tipos de datos en Java pueden dividirse en dos categorías: simples y compuestos. en general. Los simples son tipos nucleares que no se derivan de otros tipos.326 '( '$726 $ 7.GHQWLILFDGRU e . 7. Los tipos compuestos se basan en los tipos simples.326 '( '$726 6. Esta sentencia indica al compilador que reserve memoria para dos variables del tipo simple 7LSR6LPSOH con nombres . Cada tipo de datos simple soporta un conjunto de literales que le pueden ser asignados.0. D. Para crear una variable (de un tipo simple) en memoria debe declararse indicando su tipo de variable y su identificador que la identificará de forma única. junto con la manera en que dicha información ha de ser interpretada.. Estos definen los métodos de almacenamiento disponibles para representar información. así como los literales que soporta (sintaxis de los valores que se les puede asignar). La sintaxis de declaración de variables es la siguiente: TipoSimple Identificador1. En este apartado se explican los tipos de datos simples (o primitivos) que presenta Java. e incluyen las cadenas. Identificador2. como los enteros.03/(6 Es uno de los conceptos fundamentales de cualquier lenguaje de programación.Guía de iniciación al lenguaje Java. para darles valor.

7LSRV GH GDWRV HQWHURV Se usan para representar números enteros con signo. como 0xC en hexadecimal. inicial. Página 42 de 189 . Octal: Los octales aparecen con un 0 inicial delante de los dígitos. y como 014 en octal. un literal entero para el número decimal 12 se representa en Java como 12 en decimal. Por ejemplo. Hay cuatro tipos: E\WH VKRUW LQW \ ORQJ 7LSR 1Byte (8 bits) E\WH 2 Bytes (16 bits) VKRUW 4 Bytes (32 bits) LQW 8 Bytes (64 bits) ORQJ 7DEOD  7LSRV GH GDWRV HQWHURV 7DPDxR Literales enteros Son básicos en la programación en Java y presentan tres formatos: • • • Decimal: Los literales decimales aparecen como números ordinarios sin ninguna notación especial. notación similar a la utilizada en C y C++. Hexadecimal: Los hexadecimales (base 16) aparecen con un [ ó .

Octubre de 1999 Los literales enteros se almacenan por defecto en el tipo LQW. o si se trabaja con números muy grandes.0. Versión 2. (4 bytes con signo). añadiendo una L ó l al final del número. // Por defecto vale 12 E. (8 bytes con signo). con el tipo ORQJ. Un ejemplo de ello sería: long numeroLargo = 0xC.Guía de iniciación al lenguaje Java. La declaración de variables enteras es muy sencilla.

Existe la opción de usar un tipo más corto (el tipo IORDW de 4 bytes).16e-2 . La declaración de variables de coma flotante es muy similar a la de las variables enteras. // Paciente sin fiebre Se realiza un moldeado a WHPSHUDWXUD. especificándolo con una F ó f al final del número.6384e2).84) o científica (5. Pueden representarse con notación estándar (563. 4 Byte (32 bits) IORDW 8 Bytes (64 bits) GRXEOH 7DEOD  7LSRV GH GDWRV QXPpULFRV HQ FRPD IORWDQWH 7LSR 7DPDxR Literales en coma flotante Representan números decimales con partes fraccionarias. De forma predeterminada son del tipo GRXEOH (8 bytes). porque todos los literales con decimales por defecto se consideran GRXEOH. Hay dos tipos de coma flotante: IORDW y GRXEOH. Por ejemplo: double miPi = 314. 7LSRV GH GDWRV HQ FRPD IORWDQWH Se usan para representar números con partes fraccionarias. // Aproximadamente float temperatura = (float)36. F. El primero reserva almacenamiento para un número de precisión simple de 4 bytes y el segundo lo hace para un numero de precisión doble de 8 bytes.6.

Para declarar un dato del tipo booleano se utiliza la palabra reservada ERROHDQ boolean reciboPagado = false. // ¡¿Aun no nos han pagado?! G. que serán representados por los valores WUXH y IDOVH. 7LSR GH GDWRV ERROHDQ Se usa para almacenar variables que presenten dos estados. provenientes del denominado iOJHEUD GH ERRO. y verdadero cualquier número que no fuese el 0. Este tipo de literales es nuevo respecto a C/C++. lenguajes en los que el valor de falso se representaba por un 0 numérico. Literales Booleanos Java utiliza dos palabras clave para los estados: WUXH (para verdadero) y IDOVH (para falso). Representan valores bi-estado.

Debido a que el conjunto de caracteres 8QLFRGH se compone de valores de 16 bits. 7LSR GH GDWRV FDUiFWHU Se usa para almacenar caracteres 8QLFRGH simples. Página 43 de 189 . el tipo de datos FKDU se almacena en un entero sin signo de 16 bits.

De forma similar que en C/C++.0.1) y aparecen dentro de un par de comillas simples. Versión 2. Los caracteres especiales (de control y no imprimibles) se representan con una barra invertida ('\') seguida del código carácter. // Letra ’V’ H. Literales carácter Representan un único carácter (de la tabla de caracteres Unicode 1. Caracter Unicode ?XGGGG Numero octal ?GGG Barra invertida ?? Continuación ? Retroceso ?E Retorno de carro ?U Alimentación de formularios ?I Tabulación horizontal ?W Línea nueva ?Q Comillas simples ?¶ Comillas dobles ?´ Números arábigos ASCII  Alfabeto ASCII en mayúsculas $= Alfabeto ASCII en minúsculas D] 7DEOD  &DUDFWHUHV HVSHFLDOHV -DYD 'HVFULSFLyQ 5HSUHVHQWDFLyQ 9DORU 8QLFRGH ?X& ? ?X ?X' ?X& ?X ?X$ ?X ?X ?X D ?X ?X D ?X$ ?X D ?X$ Las variables de tipo FKDU se declaran de la siguiente forma: char letraV = ’\u0056’. Octubre de 1999 Java a diferencia de C/C++ distingue entre matrices de caracteres y cadenas.Guía de iniciación al lenguaje Java.

read(). La función UHDG devuelve un valor LQW. Este proceso se denomina "conversión". La conversión se lleva a cabo colocando el tipo destino entre paréntesis. // Observe la necesidad de las ’ ’ En Java es posible transformar el tipo de una variable u objeto en otro diferente al original con el que fue declarado. que se convierte en un FKDU debido a la conversión FKDU. &RQYHUVLRQ GH WLSRV GH GDWRV char letraMayuscula = ’A’.in. "moldeado" o "tipado". a la izquierda del valor que queremos convertir de la forma siguiente: char c = (char)System.

No todos los tipos se convertirán de forma segura. con lo que si contienen información útil. al convertir un ORQJ en un LQW. esta se perderá. de forma que encajen en los 32 bits del LQW. Por ello se establece la norma de que "en las conversiones el tipo destino siempre debe ser igual o mayor que el tipo fuente": Página 44 de 189 .. Por ejemplo. y el valor resultante se almacena en la variable de tipo carácter F. el compilador corta los 32 bits superiores del ORQJ (de 64 bits). El tamaño de los tipos que queremos convertir es muy importante.

Octubre de 1999 7LSR 2ULJHQ E\WH GRXEOH IORDW ORQJ LQW FKDU VKRUW VKRUW GRXEOH IORDW ORQJ LQW FKDU GRXEOH IORDW ORQJ LQW LQW GRXEOH IORDW ORQJ ORQJ GRXEOH IORDW IORDW GRXEOH 7DEOD  &RQYHUVLRQHV VLQ SpUGLGDV GH LQIRUPDFLyQ 7LSR 'HVWLQR % 9(&725(6 < 0$75.Guía de iniciación al lenguaje Java. Versión 2. En Java los vectores se declaran utilizando corchetes ( > \ @ . Si la matriz tiene solo una dimensión.0.&(6 Una matriz es una construcción que proporciona almacenaje a una lista de elementos del mismo tipo. ya sea simple o compuesto. se la denomina YHFWRU.

crea un caso de la clase 6WULQJ y define su estado. debido a que Java no deja indicar el tamaño de un vector vacío cuando le declara. Si se utiliza la forma de QHZ se establecerá el valor  a cada uno de los elementos del vector. Una instancia de la clase 6WULQJ es un objeto que ha sido creado siguiendo la descripción de la clase. // Vector de 5 números O se asigna una lista de elementos al vector: int vectorIni = { 2. 8}. La asignación de memoria al vector se realiza de forma explícita en algún momento del programa. & &$'(1$6 En Java se tratan como una clase especial llamada 6WULQJ. Página 45 de 189 . tanto después del tipo de variable como después del identificador. Vemos un ejemplo de cadena declarada con la clase 6WULQJ de Java: String capitalUSA = ”Washington D. 5. tras la declaración del tipo de datos que contendrá el vector. Cuando Java encuentra una constante de cadena. Esta representación es muy diferente de la de C/C++ de cadenas como una matriz de caracteres.”. con los caracteres que aparecen dentro de las comillas dobles. Para ello o se utiliza el operador QHZ: int vectorNumeros = new int[ 5 ].C. Por ejemplo. Se puede observar que los corchetes son opcionales en este tipo de declaración de vector. esta sería la declaración de un vector de números enteros (LQW): int vectorNumeros[ ]. Las cadenas se gestionan internamente por medio de una instancia de la clase 6WULQJ. // == int vectorIni[3]=new int[3]. Cadenas constantes Representan múltiples caracteres y aparecen dentro de un par de comillas dobles. // Vector de números Se observa la ausencia de un número que indique cuántos elementos componen el vector.. Se implementan en Java con la clase 6WULQJ.

0.Guía de iniciación al lenguaje Java. Octubre de 1999 String nombreBonito = ”Amelia”. Más tarde profundizaremos con detenimiento en las cadenas Java. Versión 2. Página 46 de 189 .

Además de realizar la operación. lo cual indica que el operador aparece entre sus operandos. se evalúa a: contador+1 La notación posfija indica que el operador aparece después de su operando: contador++ // Notación posfija. Por ejemplo el operador " " es un operador binario que asigna el valor del operando del lado derecho al operando del lado izquierdo. un operador devuelve un valor. Los operadores unarios en Java pueden utilizar tanto la notación prefija como la posfija. La notación prefija indica que el operador aparece antes que su operando. Todas los operadores binarios en Java utilizan notación infija. y en definitiva sobre identificadores o constantes. De comparación y condicionales. Por ejemplo.Guía de iniciación al lenguaje Java. dos o tres operandos. los operadores ternarios son aquellos que requieren tres operandos. el operador "" es un operador unario que incrementa el valor de su operando en una unidad. Versión 2. """:.0. El lenguaje Java tiene el operador ternario. A nivel de bits y lógicos. El valor y tipo que devuelve depende del operador y del tipo de sus operandos. y cada parte del operador aparece entre operandos: expresión ? operación1 : operación2 Los operadores de Java se pueden dividir en las siguientes cuatro categorías: Œ Œ Œ Œ Aritméticos. De asignación. 23(5$'25(6 $ . Los operadores que requieren un operando son llamados RSHUDGRUHV XQDULRV Por ejemplo. Octubre de 1999 . ++contador // Notación prefija.Ï1 Los operadores son un tipo de WRNHQV que indican una evaluación o computación para ser realizada en objetos o datos. Los operadores realizan alguna función sobre uno.. los operadores aritméticos devuelven un número como resultado de su operación.1752'8&&. Página 47 de 189 . operando1 operador operando2 Por último. ya que son parte fundamental de las expresiones. que es una sentencia similar a la if-else. se evalúa a: contador Los operadores que requieren dos operandos se llaman RSHUDGRUHV ELQDULRV. Este operador ternario usa notación infija.

print("Contados" + contador + "caracteres. Los operadores + y . Versión 2. por ejemplo para control de flujos: 2SHUDGRU     RS RS RS RS 8VR 'HVFULSFLyQ Incrementa op en 1. y -.tienen versiones unarias que realizan las siguientes operaciones: 2SHUDGRU + - 8VR +op -op 'HVFULSFLyQ Convierte op a entero si es un byte.out. El siguiente ejemplo utiliza  para concatenar la cadena "&RQWDGRV . se obtiene un entero como tipo devuelto con el valor de la suma de los dos enteros. es decir. //Suma los dos enteros divideEste % entreEste. cambiando de valor todos sus bits y sumando 1 al resultado final: 42 -> 00101010 -42 -> 11010110 Existen dos operadores aritméticos que funcionan como atajo de la combinación de otros: ++ que incrementa su operando en 1.0. o si no realizar una conversión de tipos de uno de los dos operandos al tipo del otro.&26 El lenguaje Java soporta varios operadores aritméticos para los números enteros y en coma flotante. short o char Niega aritméticamente op 7DEOD  9HUVLRQHV XQDULDV GH ORV RSHUDGRUHV  \  El operador . resto de una división entera). La utilización la correcta es crítica en situaciones donde el valor de la sentencia es utilizado en mitad de un cálculo más complejo. y otra posfija. con el valor de la variable FRQWDGRU y la cadena " FDUDFWHUHV : System. se evalúa al valor posterior al incremento 7DEOD  2SHUDFLRQHV FRQ  \  Página 48 de 189 .  (resta). Por ejemplo: sumaEste + aEste. El lenguaje Java sobrecarga la definición del operador  para incluir la concatenación de cadenas. Se incluye  (suma). se evalúa al valor anterior al incremento Decrementa op en 1.  (división). se evalúa al valor anterior al incremento Incrementa op en 1. //Calcula el resto de dividir 2 enteros 2SHUDGRU    Suma op1 y op2 RS  RS Resta op2 de op1 RS  RS Multiplica op1 por op2 RS RS Divide op1 por op2 RS  RS Calcula el resto de dividir op1 entre op2 RS RS 7DEOD  2SHUDGRUHV DULWPpWLFRV ELQDULRV GH -DYD 8VR 'HVFULSFLyQ El tipo de los datos devueltos por una operación aritmética depende del tipo de sus operandos. Estos operadores se deben utilizar con operandos del mismo tipo. se evalúa al valor posterior al incremento Decrementa op en 1. Ambos operadores tienen una versión prefija.realiza una negación del número en complemento A2.70e7.Guía de iniciación al lenguaje Java. y (módulo. si se suman dos enteros.que decrementa su operando en 1. es decir. (multiplicación)."). Octubre de 1999 % 23(5$'25(6 $5. Esta operación automáticamente convierte el valor de FRQWDGRU a una cadena de caracteres.

Guía de iniciación al lenguaje Java.21$/(6 Un operador de comparación compara dos valores y determina la relación existente entre ambos.0. Versión 2. el cual realiza la operación booleana DQG. se pueden utilizar dos operaciones diferentes de comparación con para determinar si ambas relaciones son ciertas. La siguiente tabla resume los operadores de comparación de Java: 2SHUDGRU > >= < <= == != 8VR 'HYXHOYH YHUGDGHUR VL op1 > op2 op1 es mayor que op2 op1 >= op2 op1 es mayor o igual que op2 op1 < op2 op1 es menor que op2 op1 <= op2 op1 es menor o igual que op2 op1 == op2 op1 y op2 son iguales op1 != op2 op1 y op2 son distintos 7DEOD  2SHUDGRUHV GH FRPSDUDFLyQ Los operadores de comparación suelen ser usados con los operadores condicionales para construir expresiones complejas que sirvan para la toma de decisiones.&. Por ejemplo.Ï1 < &21'. Octubre de 1999 & 23(5$'25(6 '( &203$5$&. La siguiente línea de código utiliza esta técnica para determinar si la variable LQGH[ de una matriz se encuentra entre dos límites (mayor que cero y menor que la constante 180(52B(175$'$6. el operador devuelve verdadero (WUXH) si los dos operandos son distintos. Por ejemplo. Un operador de este tipo es .

siempre evalúa op1 y op2 op1 o op2 son verdaderos. Java no evaluará el operando de la derecha: (contador < NUMERO_ENTRADAS) && ( in. mostrados en la siguiente tabla: 2SHUDGRU __ _ RS RS RS RS RS __ RS RS _ RS RS en 8VR 'HYXHOYH YHUGDGHUR VL op1 y op2 son ambos verdaderos. que se comporta como una versión reducida de la sentencia LIHOVH: expresion ? operacion1 : operacion2 El operador ": evalúa la H[SUHVLRQ y devuelve RSHUDFLyQ si es cierta. En caso de que el primer operando del operador valga falso. siempre evalúa op1 y op2 op es falso 7DEOD  2SHUDGRUHV FRQGLFLRQDOHV Además Java soporta un operador ternario. De la misma manera se relacionan los operadores || y _ para la exclusión lógica (OR). En este caso LQUHDG no será llamado y un carácter de la entrada estándar no será leído. Si el programador quiere que se evalúe la parte derecha.: ( 0 < index ) && ( index < NUMERO_ENTRADAS ) Se debe tener en cuenta que en algunos casos. el segundo operando de un operador condicional puede no ser evaluado. el ". o devuelve RSHUDFLyQ si H[SUHVLRQ es falsa. condicionalmente evalúa op2 op1 y op2 son ambos verdaderos.read() != -1 ) Si FRQWDGRU es menor que 180(52B(175$'$6. Java soporta cinco operadores condicionales . Página 49 de 189 . el valor de retorno de puede ser determinado sin evaluar el operando de la parte derecha. deberá utilizar el operador lugar de . condicionalmente evalúa op2 op1 o op2 son verdaderos.

0. y operadores lógicos de bit. Octubre de 1999 ' 23(5$'25(6 '( %. Versión 2. Existen dos tipos: los que desplazan (mueven) bits. D.7 Un operador de bit permite realizar operaciones de bit sobre los datos.Guía de iniciación al lenguaje Java.

El desplazamiento sin signo !!! funciona de la siguiente manera: Œ Œ Si se desplaza con signo el número -1 (1111). Con el desplazamiento sin signo se consigue introducir ceros por la izquierda. 2SHUDGRUHV GH GHVSOD]DPLHQWR GH ELWV 2SHUDGRU !!  !!! Desplaza los bits de op1 a la derecha op2 veces RS !! RS Desplaza los bits de op1 a la izquierda op2 veces RS  RS Desplaza los bits de op1 a la derecha op2 veces (sin signo) RS !!! RS 7DEOD  2SHUDGRUHV GH GHVSOD]DPLHQWR GH ELWV 8VR 2SHUDFLyQ Los tres operadores de desplazamiento simplemente desplazan los bits del operando de la parte izquierda el número de veces indicado por el operando de la parte derecha. mientras que un desplazamiento a la izquierda de una posición equivale a multiplicar por 2. pero un desplazamiento es más eficiente. Un desplazamiento a la derecha una posición es equivalente a dividir el operando del lado izquierdo por 2. desplaza los bits del entero 13 a la derecha una posición: 13 >> 1. seguirá valiendo -1. 110 o 6 en decimal. E. El desplazamiento ocurre en la dirección indicada por el operador. Por ejemplo. computacionalmente hablando. Se debe tener en cuenta que el bit más a la derecha se pierde en este caso. dado que la extensión de signo sigue introduciendo unos en los bits más significativos. obteniendo el número 7 (0111). que una división o multiplicación. La representación en binario del número 13 es 1101. Este tipo de desplazamientos es especialmente útil en la utilización de máscaras gráficas. la siguiente sentencia. El resultado de la operación de desplazamiento es 1101 desplazado una posición a la derecha.

En Java hay cuatro operadores de lógica de bits: 2SHUDGRU _ A a AND RS RS OR RS _ RS OR Exclusivo RS A RS Complemento aRS 7DEOD  2SHUDGRUHV GH OyJLFD GH ELWV 8VR 2SHUDFLyQ El operador realiza la operación AND de bit. WUXH/IDOVH. 1/0). Aplica la IXQFLyQ $1' sobre cada par de bits de igual peso de cada operando. La IXQFLyQ $1' es evaluada a cierto si ambos operandos son ciertos. Por ejemplo vamos a aplicar la operación $1' a los valores 12 y 13: Página 50 de 189 . 2SHUDGRUHV GH OyJLFD GH ELWV La lógica de bits (lógica de Bool) se utiliza para modelizar condiciones biestado y trabajar con ellas (cierto/falso.

final int MODIFICABLE = 8. La IXQFLyQ . HV$UUDVWUDEOH. se deberá usar la sentencia: flags = flags | VISIBLE. y de 13 es 1101. Octubre de 1999 12 & 13 El resultado de esta operación es 12. Esos indicadores deben ser diferentes unos de otros (en sus bits) para asegurar que el bit de activación no se solape con otro indicador.%/(. Aplica la IXQFLyQ . La IXQFLyQ $1' pone el bit de resultado a uno si los dos bits de los operandos son 1. por ejemplo. Convierte el falso en cierto. Aplica la IXQFLyQ 25 sobre cada par de bits de igual peso de cada operando.25 sobre cada par de bits de igual peso de cada operando. El operador ^ realiza la operación OR exclusivo de bit (XOR). La representación en binario de 12 es 1100. Cada bit de dicha variable representará el estado vigente de uno de los indicadores.25 es evaluada a cierto si los operandos tienen el mismo valor.. La IXQFLyQ 25 es evaluada a cierto si alguno de los operandos es cierto.0. Para comprobar la visibilidad se deberá usar la sentencia: if ( (flags & VISIBLE) == 1 ) //Lo que haya que hacer Página 51 de 189 . y el cierto en falso: Entre otras cosas. se deben preparar las constantes de cada indicador.6.. sino. Primero. el bit de resultado es 0: 1101 & 1100 -----1100 El operador _ realiza la operación OR de bit. se puede definir una única variable para todos ellos. Se deberán utilizar entonces manipulaciones de bit para establecer y leer cada indicador. Para activar el indicador 9. int flags = 0. los cuales muestran el estado de varios componentes del programa: HV9LVLEOH. Después se debe definir la variable de banderas. Supongamos. Para finalizar.Guía de iniciación al lenguaje Java. la manipulación bit es útil para gestionar indicadores booleanos (banderas). lo que significa que todos los indicadores están desactivados (ninguno de los bits es 1): final int VISIBLE = 1. ¿Por qué?. final int SELECCIONABLE = 4. cuyos bits deben de poder ser configurados según el estado vigente en cada indicador. final int ARRASTRABLE = 2. Versión 2. En lugar de definir una variable booleana para cada indicador. que se tiene varios indicadores booleanos en nuestro programa. el operador de complemento invierte el valor de cada bit del operando. El siguiente ejemplo inicia la variable de banderas IODJV a 0.

Los operadores con mayor precedencia son evaluados antes que los operadores con una precedencia relativa menor.$ '( 23(5$'25(6 Cuando en una sentencia aparecen varios operadores el compilador deberá de elegir en qué orden aplica los operadores. Permiten realizar operaciones aritméticas. Supongamos que necesitamos sumar un número a una variable y almacenar el resultado en la misma variable.*1$&. lógicas. Se puede indicar explícitamente al compilador de Java cómo se desea que se evalúe la expresión con paréntesis balanceados ( ). A esto se le llama SUHFHGHQFLD. Cuando en una sentencia aparecen operadores con la misma precedencia: Œ Œ Los operadores de asignación son evaluados de derecha a izquierda. Por ejemplo: int contador = 0. de la siguiente manera i += 2.op2 RS  RS op1 = op1 * op2 RS RS op1 = op1 / op2 RS  RS op1 = op1 % op2 RS RS op1 = op1 & op2 RS RS 7DEOD  2SHUDGRUHV GH DWDMR GH DVLJQDFLyQ 8VR (TXLYDOHQWH D ) 35(&('(1&. Inicia la variable FRQWDGRU con un valor  Java además proporciona varios operadores de asignación que permiten realizar un atajo en la escritura de código. La siguiente tabla muestra la precedencia asignada a los operadores de Java. La siguiente tabla muestra los operadores de atajo de asignación y sus equivalentes largos: 2SHUDGRU    op1 = op1 + op2 RS  RS op1 = op1 . Los operadores de la tabla están listados en orden de precedencia: cuanto más arriba aparezca un operador.Ï1 El operador de asignación básico es el . Octubre de 1999 ( 23(5$'25(6 '( $6.Guía de iniciación al lenguaje Java. Versión 2. como a continuación: i = i + 2. de bit y de asignación con un único operador. Los operadores en la misma línea tienen la misma precedencia: Página 52 de 189 . Se puede abreviar esta sentencia con el operador de atajo  . es preferible ser explícito e indicar con paréntesis que operadores deben ser evaluados primero. Para hacer que el código sea más fácil de leer y mantener.0. que se utiliza para asignar un valor a otro. Los operadores binarios. mayor es su precedencia. (menos los de asignación) son evaluados de izquierda a derecha.

Guía de iniciación al lenguaje Java. (parametros) expr++ expr-Operadores unarios ++expr --expr +expr -expr ~ ! Creación o conversión new (tipo) expr Multiplicación * / % Suma + Desplazamiento << Comparación < <= = instanceof Igualdad == != AND a nivel de bit & OR a nivel de bit ^ XOR a nivel de bit | AND lógico && OR lógico || Condicional ? : Asignación = += -= *= /= %= &= ^= |= <<= = = 7DEOD  3UHGHGHQFLD GH RSHUDGRUHV Por ejemplo. Como el operador de división tiene mayor precedencia que el operador de suma el compilador evaluará \ primero. Octubre de 1999 7LSR GH RSHUDGRUHV 2SHUDGRUHV GH HVWH WLSR Operadores posfijos [ ] . entonces el compilador decide basándose en la precedencia asignada a los operadores. la siguiente expresión produce un resultado diferente dependiendo de si se realiza la suma o división en primer lugar: x + y / 100 Si no se indica explícitamente al compilador el orden en que se quiere que se realicen las operaciones. Versión 2. Así: x + y / 100 Es equivalente a: x + (y / 100) Página 53 de 189 .0.

1752'8&&. return. in. Así. goto 7DEOD  (VWUXFWXUDV GH FRQWURO Aunque JRWR es una palabra reservada. Este código además de poco elegante sería inviable para una repetición de 3000 lecturas. que facilitan que determinadas acciones se realicen varias veces. label:.read(). Se puede utilizar las sentencias de bifurcación en su lugar. do-while Misceláneo break. leer 3 caracteres de un flujo de entrada LQ se codificaría: in. (6758&785$6 '( &21752/ $ . nuestro ejemplo se podría indicar como: int i=0. y en definitiva. i++ ) in. in. % /$6 6(17(1&. Por eso aparecen las estructuras de control. Donde bastaría cambiar el  por cualquier otro número para que la lectura se repitiese ese número de veces.Guía de iniciación al lenguaje Java.read().7&+ D.$6 &21'.read(). while. actualmente el lenguaje Java no soporta la sentencia JRWR. Octubre de 1999 . El lenguaje Java soporta las estructuras de control: 6HQWHQFLD &ODYH Toma de decisión if-else. continue.21$/(6 . for ( i=0 .Ï1 Durante un programa existen acciones que se han de repetir un número determinado de veces.&. Versión 2.0. tomar decisiones de qué hacer en función de las condiciones que se den en el programa en un momento dado de su ejecución. switch-case Bucle for.read().) < 6:. i <= 3 . mientras que una condición se cumpla. Por ejemplo..

y un bloque de código puede ser simplemente la sentencia vacía  para representar que en ese caso no se ha de ejecutar nada. /D VHQWHQFLD LI  HOVH La sentencia LIHOVH de Java dota a los programas de la habilidad de ejecutar distintos conjuntos de sentencias según algún criterio. La sintaxis de la sentencia LIHOVH es: if ( condición ) Bloque de código a ejecutar si la condición es cierta else Bloque de código a ejecutar si la condición es falsa La parte del HOVH es opcional. Página 54 de 189 .

} else if (valor > 80) {clasificacion=’B’.println( "Su peticion esta siendo atendida" ). char clasificacion.println( "Cancelando accion" ).} Se pueden escribir los LI en las mismas líneas que los HOVH. supongamos que se desea escribir un programa que clasifique según el contenido de una variable YDORU. Este sistema de programación (HOVH LI.Guía de iniciación al lenguaje Java. pero desde este tutorial se insta a utilizar la forma indentada (como se ha podido ver en el ejemplo).} else if (valor > 70) {clasificacion=’C’. B de 90-81. Esto es lo que se suele denominar como sentencias HOVH LI. C para 80-71 y F si no es ninguno de los anteriores: int valor.out. Por ejemplo. Octubre de 1999 Supongamos que un programa debe realizar diferentes acciones dependiendo de si el usuario oprime el botón aceptar o el botón cancelar en una ventana de dialogo.out. } Se pueden anidar expresiones LIHOVH. } else { // código para realizar la acción Cancelar System.0.} else {clasificacion=’F’. asigne una letra a una variable FODVLILFDFLRQ: A para un valor del 100-91. Nuestro programa puede realizar esto usando la sentencia LI  HOVH: // La respuesta es Aceptar o Cancelar if (respuesta == Aceptar) { // código para realizar la acción Aceptar System. Versión 2. pues es más clara para el lector. para poder implementar aquellos casos con múltiples acciones. if (valor > 90) {clasificacion=’A’.

E. y por ello el lenguaje Java incluye la sentencia VZLWFK que veremos a continuación. para dirigir el flujo de control de variables con múltiples valores. no es demasiado recomendable.

/D VHQWHQFLD VZLWFK Mediante la sentencia VZLWFK se puede seleccionar entre varias sentencias según el valor de cierta expresión. La forma general de VZLWFK es la siguiente: Página 55 de 189 .

out. break. . Las sentencias EUHDN que aparecen tras cada FRQMXQWR'H6HQWHQFLDV provocan que el control salga del VZLWFK y continúe con la siguiente instrucción al VZLWFK. break.Guía de iniciación al lenguaje Java. break. case 12: System.out. Octubre de 1999 switch ( expresionMultivalor ) { case valor1 : conjuntoDeSentencias.println( "Marzo" ). Se puede utilizar la sentencia VZLWFK para realizar esta operación: int meses. Cada sentencia FDVH debe ser única y el YDORU que evalúa debe ser del mismo tipo que el devuelto por la H[SUHVLyQ0XOWLYDORU de la sentencia VZLWFK. para lo que habrá que eliminar algunos EUHDN Finalmente. break. Existen ciertas situaciones en las que se desea ejecutar secuencialmente algunas o todas las sentencias FDVH. default: System. break. break.println( "Enero" ).0. case 2: System. break. Por ejemplo. y se desea imprimir el nombre del mes en que estemos. se puede usar la sentencia GHIDXOW para manejar los valores que no son explícitamente contemplados por alguna de las sentencias FDVH.out. case valor2 : conjuntoDeSentencias. if ( meses == 1 ) { System. Versión 2. break.out.println( "Mes no valido" ). se puede implementar esta estructura como una sentencia LI HOVH LI: int meses.println( "Febrero" ). case valor3: conjuntoDeSentencias. . } La sentencia VZLWFK evalúa la H[SUHVLyQ0XOWLYDORU y ejecuta el FRQMXQWR'H6HQWHQFLDV que aparece junto a la cláusula FDVH cuyo YDORU corresponda con el de la H[SUHVLyQ0XOWLYDORU. //Demas meses // .println( "Enero" ). Las sentencias EUHDN son necesarias porque sin ellas se ejecutarían secuencialmente las sentencias FDVH siguientes.out.out.out. case 3: System.println( "Diciembre" ). break. Su uso es altamente recomendado. } else if ( meses == 2 ) { System. switch ( meses ){ case 1: System. default: conjuntoDeSentencias.println( "Febrero" ). } Por supuesto. supongamos un programa con una variable entera PHVHV cuyo valor indica el mes actual. Página 56 de 189 .

Versión 2. & 6(17(1&.$6 '( .Ï1 2 %8&/(6 )25 '2 :+.0./( D. aunque se recomienda utilizar VZLWFK para sentencias con más de tres o cuatro posibilidades. Octubre de 1999 } // Y así para los demás meses El decidir si usar la sentencia LI o VZLWFK depende del criterio de cada caso.7(5$&. Se puede decidir cuál usar basándonos en la legibilidad.Guía de iniciación al lenguaje Java.

La forma general del bucle ZKLOH es la siguiente: while ( expresiónBooleana ) { sentencias. Sirve para realizar una acción sucesivamente mientras se cumpla una determinada condición. }. Las VHQWHQFLDV se ejecutan mientras la H[SUHVLyQ%RROHDQD tenga un valor de YHUGDGHUR. E. } Con él se podrían eliminar los bucles GRZKLOH y IRU por ser extensiones de éste. pero que se incluyen en el lenguaje para facilitar la programación. Se utiliza. por ejemplo para estar en un bucle del que no hay que salir hasta que no se cumpla una determinada condición. while ( i <= 100 ) { i = i * 2. multiplicar un número por 2 hasta que sea mayor que 100: int i = 1. Por ejemplo. %XFOH ZKLOH El bucle ZKLOH es el bucle básico de iteración.

se sabe que siempre se debe leer por lo menos un carácter: int c. pero tiene sus usos. cuando se lee información de un archivo. Página 57 de 189 .read( ).in. } while ( expresiónBooleana ). do { c = System. pero en el bucle ZKLOH la expresión se evalúa al principio del bucle y en el bucle GRZKLOH la evaluación se realiza al final. La forma general del bucle GRZKLOH es la siguiente: do { sentencias. La sentencia GRZKLOH es el constructor de bucles menos utilizado en la programación. Por ejemplo. cuando el bucle deba ser ejecutado por lo menos una vez. %XFOH GRZKLOH El bucle GRZKLOH es similar al bucle ZKLOH.

// No se puede leer más (Fin fichero) F.0. Versión 2.Guía de iniciación al lenguaje Java. Octubre de 1999 // Sentencias para tratar el carácter c } while ( c != -1 ).

El incremento es una expresión que es invocada en cada iteración del bucle. Se debe utilizar el bucle IRU cuando se conozcan las restricciones del bucle (su instrucción de iniciación. Por eso el bucle IRU está tan extendido. i < 10 . o los caracteres de una cadena: // cad es una cadena (String) for ( int i = 0. el bucle termina.length() . terminación . &217. %XFOH IRU Mediante la sentencia IRU se resume un bucle GRZKLOH con una iniciación previa. incremento ) sentencias. Esta expresión se evalúa al final de cada iteración del bucle. La iniciación es una sentencia que se ejecuta una vez antes de entrar en el bucle. Cuando la expresión se evalúa a falso.18( < 5(7851 D. i++ ) Algunos (o todos) estos componentes pueden omitirse. i++){ // hacer algo con el elemento i-ésimo de cad } ' 6(17(1&. los bucles IRU son utilizados comúnmente para iterar sobre los elementos de una matriz. inmediatamente antes de comenzar los bucles. Es muy común que en los bucles ZKLOH y GRZKLOH se inicien las variables de control de número de pasadas por el bucle.$6 '( 6$/72 %5($. En realidad puede ser una acción cualquiera. pero los puntos y coma siempre deben aparecer (aunque sea sin nada entre sí). Por ejemplo. La forma general de la sentencia IRU es la siguiente: for ( iniciación . aunque se suele utilizar para incrementar una variable contador: for ( i = 0 . La terminación es una expresión que determina cuándo se debe terminar el bucle. criterio de terminación e instrucción de incremento). i < cad.

que no es soportada por el lenguaje Java. Ya se ha visto anteriormente la sentencia EUHDN dentro de la sentencia VZLWFK. El uso de la sentencia break con sentencias etiquetadas es una alternativa al uso de la sentencia JRWR. 6HQWHQFLD EUHDN La sentencia EUHDN provoca que el flujo de control salte a la sentencia inmediatamente posterior al bloque en curso. Se puede etiquetar una sentencia poniendo una identificador Java válido seguido por dos puntos antes de la sentencia: nombreSentencia: sentenciaEtiquetada Página 58 de 189 .

out. E.print(" i="+i). sino que se salta al final del bucle L. y con saltos de flujo no controlados. //Sale de los dos bucles!!! System. Versión 2.Guía de iniciación al lenguaje Java. llevando el flujo del programa al final de la sentencia de programa que indique: break nombreSentencia2. for( int j=1.print(" j="+j).print("No llega aquí"). j<10. a: for( int i=1.println("Ejemplo de break como ’goto’ "). } } Al interpretar EUHDN D. j++ ){ if ( j==5 ) break a. i++ ){ System.out. i<10. basada en JRWR.out. obteniéndose: i=1 j=1 j=2 j=3 1RWD Se desaconseja esta forma de programación.out. Un ejemplo de esto sería el programa: void gotoBreak() { System.0. no solo se rompe la ejecución del bucle interior (el de M). } System. Octubre de 1999 La sentencia EUHDN se utiliza para salir de una sentencia etiquetada.

En los bucles IRU además en ese momento se ejecuta la cláusula de incremento (antes de la evaluación).out. 6HQWHQFLD FRQWLQXH Del mismo modo que en un bucle se puede desear romper la iteración. pero dejando pasar una determinada iteración. } Del mismo modo que EUHDN. aunque no puede ser llamada fuera de un bucle. si Página 59 de 189 . que vuelve a ser evaluada en ese momento. y el bucle continúa o no dependiendo del resultado de la evaluación.print( " " + i ). también se puede desear continuar con el bucle. System. Tras la invocación a una sentencia FRQWLQXH se transfiere el control a la condición de terminación del bucle. Con ello podemos referirnos a un bloque superior. i++ ) { if ( ( i % 3 ) == 0 ) continue. Por ejemplo el siguiente fragmento de código imprime los números del 0 al 9 no divisibles por 3: for ( int i = 0 . Se puede usar la sentencia FRQWLQXH dentro de los bucles para saltar a otra sentencia. en las sentencias FRQWLQXH se puede indicar una etiqueta de bloque al que hace referencia. i < 10 .

el siguiente fragmento de código: void gotoContinue( ) { f: for ( int i=1. j<5. i <5. Octubre de 1999 estamos en bucles anidados. y con saltos de flujo no controlados. continue f. Si dicha etiqueta no es indicada.Guía de iniciación al lenguaje Java.0.out. } } } En este código la sentencia FRQWLQXH termina el bucle de M y continua el flujo en la siguiente iteración de i. Versión 2. F. j++ ) { if ( j>i ) { System.print( " " + (i*j) ). basada en JRWR. se presupone que nos referimos al bucle en el que la sentencia FRQWLQXH aparece. i++ ) { for ( int j=1.println(" ").out. } System. Ese método imprimiría: 1 2 4 3 6 9 4 8 12 16 1RWD Se desaconseja esta forma de programación. Por ejemplo.

Cuando un método se declara como YRLG se debe usar la forma de UHWXUQ sin indicarle ningún valor. int devuelveContadorIncrementado(){ return ++contador. 6HQWHQFLD UHWXUQ La última de las sentencias de salto es la sentencia UHWXUQ. boolean condicion. simplemente se debe poner el valor (o una expresión que calcule el valor) a continuación de la palabra UHWXUQ El valor devuelto por UHWXUQ debe coincidir con el tipo declarado como valor de retorno del método. } void metodoReturn(){ //Sentencias if ( condicion == true ) Página 60 de 189 . que puede usar para salir del método en curso y retornar a la sentencia dentro de la cual se realizó la llamada. Esto se hace para no ejecutar todo el código del programa: int contador. Para devolver un valor.

justo en el momento en que esas condiciones se den.21(6 Las excepciones son otra forma más avanzada de controlar el flujo de un programa.. *HVWLyQ GH H[FHSFLRQHV \ HUURUHV de este tutorial.Guía de iniciación al lenguaje Java. Octubre de 1999 return. Página 61 de 189 .&(3&.0. Estudiaremos más este sistema de control en el capítulo . //Más sentencias a ejecutar si condición no vale true } ( (. Versión 2. Con ellas se podrán realizar acciones especiales si se dan determinadas condiciones.

int y) { int dx= this. A partir de ahora es cuando entramos la verdadera potencia de Java como lenguaje orientado a objetos: las clases y los objetos. int paramY ) { x = paramX. return Math. int paramY ) { this. no modificamos la variable de instancia!!! this.. } void inicia2( int x. Durante todo este capítulo se va a trabajar en la construcción de una clase 0L3XQWR.x – pX. que modeliza un punto en un espacio plano: class MiPunto{ int x. y = paramY.Ï1 Durante los capítulos anteriores se han dado unas nociones básicas de la sintaxis de Java. // No hace falta this } MiPunto() { inicia(-1.sqrt(dx*dx + dy*dy).1752'8&&. } double distancia(int x.-1) hace lo mismo } } Página 62 de 189 . int y ) { x = x. int paramY ) { return ( paramX + paramY ). ya que a partir de ahora los conceptos que en él se exponen se darán por entendidos. //Por defecto .-1). // Ojo.QWURGXFFLyQ D OD SURJUDPDFLyQ RULHQWDGD D REMHWRV de este tutorial. o que no conozcan las nociones básicas de paradigma conviene que lean el capítulo . Octubre de 1999 .y – pY.0. &/$6(6 < 2%-(726 $ .x = paramX.Guía de iniciación al lenguaje Java. } void metodoVacio( ) { } void inicia( int paramX. Versión 2. int dy = this.y = y. // Este this se puede omitir y = paramY. int metodoSuma( int paramX. this(-1. . // Modificamos la variable de instancia!!! } MiPunto( int paramX. Aquellas personas que nunca hayan programado en un lenguaje orientado a objeto. y.

Versión 2.&.1.0.Ï1 '( 81$ &/$6( D. Octubre de 1999 % '().Guía de iniciación al lenguaje Java.

y se les suele asignar la extensión MDYD  Por ejemplo la clase 0L3XQWR se guardaría en un fichero que se llamase 0L3XQWRMDYD. . el nombre de la clase y el de archivo fuente han de ser exactamente iguales. Los programas en Java completos constarán por lo general de varias clases de Java en distintos archivos fuente. han de ser identificadores Java válidos. . Para crear una clase sólo se necesita un archivo fuente que contenga la palabra clave reservada FODVV seguida de un identificador legal y un bloque delimitado por dos llaves para el cuerpo de la clase. en forma de métodos. Aunque la clase 0L3XQWR es sintácticamente correcta. } // . La forma general de una definición de clase es: class Nombre_De_Clase { tipo_de_variable nombre_de_atributo1. que son los objetos reales. Página 63 de 189 . Las clases típicas de Java incluirán variables y métodos de instancia. Cuando se ejecuta un programa en Java. class MiPunto { } Un archivo de Java debe tener el mismo nombre que la clase que contiene. Por lo tanto define la estructura de un objeto y su interfaz funcional. es lo que se viene a llamar una FODVH YDFtD. como los QRPEUHBGHBDWULEXWR y QRPEUHBGHBPpWRGR. tipo_de_variable nombre_de_atributo2. . han de ser tipos simples Java o nombres de otras clases ya definidas. } Los tipos WLSRBGHBYDULDEOH y WLSRBGHYXHOWR. Hay que tener presente que en Java se diferencia entre mayúsculas y minúsculas.QWURGXFFLyQ El elemento básico de la programación orientada a objetos en Java es la clase. . Una clase es una plantilla para un objeto. // . el sistema utiliza definiciones de clase para crear instancias de las clases. es decir. una clase que no hace nada. . Tanto 1RPEUHB'HB&ODVH. Los términos instancia y objeto se utilizan de manera indistinta. } tipo_devuelto nombre_de_método2( lista_de_parámetros ) { cuerpo_del_método2. tipo_devuelto nombre_de_método1( lista_de_parámetros ) { cuerpo_del_método1. Una clase define la forma y comportamiento de un objeto.

Octubre de 1999 E.Guía de iniciación al lenguaje Java. Versión 2.0.

a de este mismo apartado). Cuando se realiza una instancia de una clase (creación de un objeto) se reservará en la memoria un espacio para un conjunto de datos como el que definen los atributos de una clase. /RV DWULEXWRV Los datos se encapsulan dentro de una clase declarando variables dentro de las llaves de apertura y cierre de la declaración de la clase. A este conjunto de variables se le denomina YDULDEOHV GH LQVWDQFLD. con dos atributos enteros llamados [ e \. Se declaran igual que las variables locales de un método en concreto. este es un programa que declara una clase 0L3XQWR. Por ejemplo. class MiPunto { int x. véase el punto C. } Los atributos se pueden declarar con dos clases de tipos: un tipo simple Java (ya descritos). o el nombre de una clase (será una UHIHUHQFLD D REMHWR. F. variables que se conocen como atributos. y.

la declaración del método debería incluir un par de paréntesis vacíos (sin YRLG): void metodoVacio( ) { }. int paramY ) { return ( paramX + paramY ). }. sus capacidades y comportamiento. Un método ha de tener por nombre cualquier identificador legal distinto de los ya utilizados por los nombres de la clase en que está definido. El método LQLFLD . En el caso de que no se desee devolver ningún valor se deberá indicar como tipo la palabra reservada YRLG. Así mismo. de sintaxis WLSR LGHQWLILFDGRU separadas por comas. por lo que los métodos se pueden referir directamente a ellas. que tendrá su propio conjunto único de variables de instancia. Los métodos se declaran al mismo nivel que las variables de instancia dentro de una definición de clase. /RV PpWRGRV Los métodos son subrutinas que definen la interfaz de una clase. si no se desean parámetros. La forma general de una declaración de método es: tipo_devuelto nombre_de_método( lista-formal-de-parámetros ) { cuerpo_del_método. En la declaración de los métodos se define el tipo de valor que devuelven y a una lista formal de parámetros de entrada. Los métodos son llamados indicando una instancia individual de la clase. } Por ejemplo el siguiente método devuelve la suma de dos enteros: int metodoSuma( int paramX.

para establecer valores a las dos variables de instancia sería el siguiente: Página 64 de 189 .

Guía de iniciación al lenguaje Java. Versión 2.0. Octubre de 1999

void inicia( int paramX, int paramY ) { x = paramX; y = paramY; } & /$ ,167$1&,$&,Ï1 '( /$6 &/$6(6 /26 2%-(726
D

5HIHUHQFLDV D 2EMHWR H ,QVWDQFLDV

Los tipos simples de Java describían el tamaño y los valores de las variables. Cada vez que se crea una clase se añade otro tipo de dato que se puede utilizar igual que uno de los tipos simples. Por ello al declarar una nueva variable, se puede utilizar un nombre de clase como tipo. A estas variables se las conoce como UHIHUHQFLDV D REMHWR. Todas las referencias a objeto son compatibles también con las instancias de subclases de su tipo. Del mismo modo que es correcto asignar un E\WH a una variable declarada como LQW, se puede declarar que una variable es del tipo 0L&ODVH y guardar una referencia a una instancia de este tipo de clase:
MiPunto p;

Esta es una declaración de una variable S que es una referencia a un objeto de la clase 0L3XQWR, de momento con un valor por defecto de QXOO. La referencia QXOO es una referencia a un objeto de la clase 2EMHFW, y se podrá convertir a una referencia a cualquier otro objeto porque todos los objetos son KLMRV de la clase 2EMHFW.
E

&RQVWUXFWRUHV

Las clases pueden implementar un método especial llamado FRQVWUXFWRU. Un constructor es un método que inicia un objeto inmediatamente después de su creación. De esta forma nos evitamos el tener que iniciar las variables explícitamente para su iniciación. El constructor tiene exactamente el mismo nombre de la clase que lo implementa; no puede haber ningún otro método que comparta su nombre con el de su clase. Una vez definido, se llamará automáticamente al constructor al crear un objeto de esa clase (al utilizar el operador QHZ). El constructor no devuelve ningún tipo, ni siquiera YRLG. Su misión es iniciar todo estado interno de un objeto (sus atributos), haciendo que el objeto sea utilizable inmediatamente; reservando memoria para sus atributos, iniciando sus valores... Por ejemplo:
MiPunto( ) { inicia( -1, -1 ); }

Este constructor denominado FRQVWUXFWRU SRU GHIHFWR, por no tener parámetros, establece el valor  a las variables de instancia [ e \ de los objetos que construya. El compilador, por defecto ,llamará al constructor de la superclase 2EMHFW

recibe dos parámetros: Página 65 de 189 . Este otro constructor. sin embargo. si no se especifican parámetros en el constructor.

Se llama al método constructor justo después de crear la instancia y antes de que QHZ devuelva el control al punto de la llamada. Así. System. paramY ). Se muestra en la pantalla: p1. se debe de crear una clase que contenga un método PDLQ . int paraY ) { inicia( paramX.y ). cuando ejecutamos el siguiente programa: MiPunto p1 = new MiPunto(10... 20).x = 10 y = 20 Para crear un programa Java que contenga ese código. Versión 2. } La lista de parámetros especificada después del nombre de una clase en una sentencia QHZ se utiliza para pasar parámetros al constructor.println( “p1.Guía de iniciación al lenguaje Java. Octubre de 1999 MiPunto( int paraX.x = “ + p1.0.out.x + “ y = “ + p1.

véase el capítulo . así como los tipos de programas que se pueden crear en Java. El intérprete MDYD se ejecutará el método PDLQ de la clase que se le indique como parámetro.. F.. &UHDFLyQ GH SURJUDPDV -DYD de este tutorial. Para más información sobre cómo crear y ejecutar un programa.

3). Aunque tan sólo se creó un objeto 0L3XQWR. que es controlador por la referencia a objeto S. Por ejemplo: MiPunto p2 = new MiPunto(2. hay dos variables (S y S) que lo referencian. S todavía apunta al objeto creado por el operador QHZ. sin afectarlo: p2 = null. Hay una distinción crítica entre la forma de manipular los tipos simples y las clases en Java: Las referencias a objetos realmente no contienen a los objetos a los que referencian. De hecho. Página 66 de 189 . a lo que se denomina UHFRJLGD GH EDVXUD. Este es un ejemplo de la creación de una instancia de 0L3XQWR. La asignación de S a S no reserva memoria ni modifica el objeto. Cualquier cambio realizado en el objeto referenciado por S afectará al objeto referenciado por S. De esta forma se pueden crear múltiples referencias al mismo objeto. Cuando ya no haya ninguna variable que haga referencia a un objeto. las asignaciones posteriores de S simplemente desengancharán S del objeto. // p3 todavía apunta al objeto creado con new Aunque se haya asignado QXOO a S. (O RSHUDGRU QHZ El operador QHZ crea una instancia de una clase (REMHWRV) y devuelve una referencia a ese objeto. como por ejemplo: MiPunto p3 =p2. Java reclama automáticamente la memoria utilizada por ese objeto.

99 ). La potencia de las variables de instancia es que se obtiene un conjunto distinto de ellas cada vez que se crea un objeto nuevo.y). Octubre de 1999 Cuando se realiza una instancia de una clase (mediante QHZ) se reserva en la memoria un espacio para un conjunto de datos como el que definen los atributos de la clase que se indica en la instanciación. A este conjunto de variables se le denomina YDULDEOHV GH LQVWDQFLD.y)...0.out. System. p4.x = 42 y = 99 ' $&&(62 $/ 2%-(72 D. MiPunto p4 = new MiPunto( 10.out.println(“p4..x = “ + p5. MiPunto p5 = new MiPunto( 42..x + “ y = “ + p4. 20 ).x = 10 y = 20 p5. por lo que los cambios sobre las variables de instancia de un objeto no tienen efecto sobre las variables de instancia de otro.println(“p5. Es importante el comprender que cada objeto tiene su propia copia de las variables de instancia de su clase.x = “ + p4. Este es el aspecto de salida cuando lo ejecutamos. Versión 2. System.x + “ y = “ + p5.Guía de iniciación al lenguaje Java. El siguiente programa crea dos objetos 0L3XQWR y establece los valores de [ e \ de cada uno de ellos de manera independiente para mostrar que están realmente separados.

(O RSHUDGRU SXQWR .

Y=40 Durante las impresiones (método SULQWOQ .println (“p6.x + “ .x + “ . X=30 ..2. X=10 .1. Y=“ + p6. se observa la siguiente salida: p6. Y=20 p6. 20 ). mediante su referencia a objeto: referencia_a_objeto. X=“ + p6. 40 ).. X=“ + p6.y). El operador punto (. Cuando se ejecuta este programa. System.y).) se utiliza para acceder a las variables de instancia y los métodos contenidos en un objeto. almacenar algunos valores en él e imprimir sus valores finales: MiPunto p6 = new MiPunto( 10.inicia( 30. System. p6. Y=“ + p6.2.out.nombre_de_método( lista-de-parámetros ) Hemos creado un ejemplo completo que combina los operadores QHZ y punto para crear un objeto 0L3XQWR..println (“p6.nombre_de_variable_de_instancia referencia_a_objeto.out..1.

y entre una impresión y otra se llama al método LQLFLD .) Ve accede al valor de las variables mediante S[ y S\.

cambiando los valores de las variables de instancia. Este es uno de los aspectos más importantes de la diferencia entre la programación orientada a objetos y la programación estructurada. Cuando se llama al método SLQLFLD ..

. lo primero que se hace en el método es sustituir los nombres de los atributos Página 67 de 189 .

Guía de iniciación al lenguaje Java. Si otros objetos llaman a LQLFLD .0. Versión 2. Así por ejemplo [ se convertirá en S[. Octubre de 1999 de la clase por las correspondientes variables de instancia del objeto con que se ha llamado.

E. no se producen HIHFWRV ODWHUDOHV.. incluso si lo hacen de una manera concurrente. ya que las variables de instancia sobre las que trabajan son distintas.

seleccionados a través de otras instancias. que se utiliza dentro de cualquier método para referirse al objeto actual. El siguiente constructor llama al constructor parametrizado 0L3XQWR [\. Si hay dos objetos que utilicen el mismo código. El valor WKLV se refiere al objeto sobre el que ha sido llamado el método actual. Un refinamiento habitual es que un constructor llame a otro para construir la instancia correctamente. cada uno tiene su propio valor único de WKLV. Se puede utilizar WKLV siempre que se requiera una referencia a un objeto del tipo de una clase actual. /D UHIHUHQFLD WKLV Java incluye un valor de referencia especial llamado WKLV.

No se utilizan [ e \ como nombres de parámetro para el método LQLFLD. porque ocultarían las variables de instancia [ e \ reales del ámbito del método. Si lo hubiésemos hecho. // Ojo. int y ) { x = x. para terminar de iniciar la instancia: MiPunto() { this( -1. incluyendo parámetros formales de métodos. que se solapen con los nombres de las variables de instancia.y = y.Ï1 '(/ 2%-(72 D. -1 ). // Llama al constructor parametrizado } En Java se permite declarar variables locales. // Modificamos la variable de instancia!!! } ( /$ '(6758&&. ocultando la variable de instancia [ void inicia2( int x. entonces [ se hubiera referido al parámetro formal. no modificamos la variable de instancia!!! this.

/D GHVWUXFFLyQ GH ORV REMHWRV Cuando un objeto no va a ser utilizado. E. así como los recursos que poseía. A esta acción se la da el nombre de GHVWUXFFLyQ GHO REMHWR. En Java la destrucción se puede realizar de forma automática o de forma personalizada. el espacio de memoria de dinámica que utiliza ha de ser liberado. en función de las características del objeto. permitiendo al programa disponer de todos los recursos posibles.

Página 68 de 189 . /D GHVWUXFFLyQ SRU GHIHFWR 5HFRJLGD GH EDVXUD El intérprete de Java posee un sistema de recogida de basura. que por lo general permite que no nos preocupemos de liberar la memoria asignada explícitamente.

El sistema de recogida de basura se ejecuta periódicamente. Versión 2. buscando objetos que ya no estén referenciados. Octubre de 1999 El recolector de basura será el encargado de liberar una zona de memoria dinámica que había sido reservada mediante el operador QHZ. F. sale del ámbito de utilización. o no es referenciado nuevamente). cuando el objeto ya no va a ser utilizado más durante el programa (por ejemplo.0.Guía de iniciación al lenguaje Java.

Esto se hace mediante la GHVWUXFFLyQ SHUVRQDOL]DGD. un sistema similar a los destructores de C++. para asegurar que dicho recurso se libera. En este caso sería acertado el utilizar la finalización explícita. /D GHVWUXFFLyQ SHUVRQDOL]DGD ILQDOL]H A veces una clase mantiene un recurso que no es de Java como un descriptor de archivo o un tipo de letra del sistema de ventanas. Para especificar una GHVWUXFFLyQ SHUVRQDOL]DGD se añade un método a la clase con el nombre ILQDOL]H class ClaseFinalizada{ ClaseFinalizada() { // Constructor // Reserva del recurso no Java o recurso compartido } protected void finalize() { // Liberación del recurso no Java o recurso compartido } } El intérprete de Java llama al método ILQDOL]H .

. Debe observarse que el método ILQDOL]H . si existe cuando vaya a reclamar el espacio de ese objeto. mediante la recogida de basura.

Página 69 de 189 . es de tipo SURWHFWHG YRLG y por lo tanto deberá de sobreescribirse con este mismo tipo.

Página 70 de 189 . Dichas interrelaciones. además de crear los suyos propios. el punto más alto de la jerarquía es la clase 2EMHFW de la cual derivan todas las demás clases.Guía de iniciación al lenguaje Java.Ï1 La verdadera potencia de la programación orientada a objetos radica en su capacidad para reflejar la abstracción que el cerebro humano realiza automáticamente durante el proceso de aprendizaje y el proceso de análisis de información. Versión 2. al permitir descomponer un problema de cierta magnitud en un conjunto de problemas menores subordinados del primero.0. La capacidad de descomponer un problema o concepto en un conjunto de objetos relacionados entre sí. Así. Las personas percibimos la realidad como un conjunto de objetos interrelacionados. se consideran dos tipos de herencia. Octubre de 1999 ..PDJHQ  (MHPSOR GH RWUR iUERO GH KHUHQFLD Los descendientes de una clase heredan todas las variables y métodos que sus ascendientes hayan especificado como KHUHGDEOHV. los defensores de la programación orientada a objetos afirman que esta técnica se adecua mejor al funcionamiento del cerebro humano.$ 0Ò/7. una clase sólo puede derivar de una única superclase. En el caso de la primera. Clase Padre Clase Hija1 Clase Hija2 . Relaciona las clases de manera jerárquica. una clase SDGUH o VXSHUFODVH sobre otras clases KLMDV o VXEFODVHV. En Java.1752'8&&. % -(5$548Ë$ La herencia es el mecanismo fundamental de relación entre clases en la orientación a objetos.3/( En la orientación a objetos. /$ +(5(1&. pueden verse como un conjunto de abstracciones y generalizaciones que se han ido asimilando desde la niñez. que se puede mostrar mediante un árbol de herencia. nos permite definir nuevas clases derivadas de otra ya existente. La característica de herencia. En todo lenguaje orientado a objetos existe una jerarquía. & +(5(1&. Para el segundo tipo. Así logramos definir una jerarquía de clases. y cuyo comportamiento es fácilmente identificable. una clase puede descender de varias superclases. que la especializan de alguna manera. mediante la que las clases se relacionan en términos de herencia.$ $ . puede ser muy útil para el desarrollo de programas informáticos. simple y múltiple.

// Nuevo atributo } } La palabra clave H[WHQGV se utiliza para decir que deseamos crear una subclase de la clase que es nombrada a continuación.21(6 (1 /$ +(5(1&. creamos una clase 0L3XQWR'. MiPunto3D( ) { x = 0. // Heredado de MiPunto y = 0. dineroDisponible.Ï1 Para indicar que una clase deriva de otra. si bien se compensa de cierta manera la inexistencia de herencia múltiple con un concepto denominado LQWHUIDFH. y son heredados por las subclases. se usa el término H[WHQGV. ' '(&/$5$&. ( /.Guía de iniciación al lenguaje Java. // Métodos public int getApuesta() { Por ejemplo: Página 71 de 189 . en nuestro caso 0L3XQWR' es hija de 0L3XQWR. heredando sus propiedades (métodos y atributos). SURWHFWHG: Los miembros declarados SURWHFWHG son accesibles sólo para sus subclases class Padre { // Hereda de Object // Atributos private int numeroFavorito. Versión 2. para una mayor sencillez del lenguaje. Octubre de 1999 En Java sólo se dispone de herencia simple. los miembros (atributos y métodos) de las clases tienen tres modificadores posibles de control de acceso: Œ Œ Œ SXEOLF: Los miembros declarados SXEOLF son accesibles en cualquier lugar en que sea accesible la clase. y para controlar la herencia por las subclase. nacidoHace. // Heredado de MiPunto z = 0.7$&.0.$ Todos los campos y métodos de una clase son siempre accesibles para el código de la misma clase. que estudiaremos más adelante.0. como en el siguiente ejemplo: public class SubClase extends SuperClase { // Contenido de la clase } Por ejemplo. SULYDWH: Los miembros declarados SULYDWH son accesibles sólo en la propia clase. hija de la clase ya mostrada 0L3XQWR: class MiPunto3D extends MiPunto { int z. Para controlar el acceso desde otras clases.

Octubre de 1999 return numeroFavorito.Guía de iniciación al lenguaje Java. } protected int getEdad() { return nacidoHace. } private int getSaldo() { return dineroDisponible. Versión 2. } } class Hija extends Padre { // Definición } class Visita { // Definición } En este ejemplo. un objeto de la clase +LMD.0. hereda los tres atributos (QXPHUR)DYRULWR. QDFLGR+DFH y GLQHUR'LVSRQLEOH) y los tres métodos ( JHW$SXHVWD .

. JHW(GDG .

y JHW6DOGR .

Cuando se llame al método JHW(GDG . y podrá invocarlos. ) de la clase 3DGUH.

Sin embargo. y no de uno de la clase 3DGUH. un objeto de la clase +LMD. de un objeto de la clase +LMD. se devolverá el valor de la variable de instancia QDFLGR+DFH de ese objeto. no podrá invocar al método JHW6DOGR .

con lo que se evita que el +LMR conozca el estado de la cuenta corriente de un 3DGUH. solo podrá acceder al método JHW$SXHVWD . La clase 9LVLWD. de un objeto de la clase 3DGUH.

Todas las clases derivan.. La clase 2EMHFW aporta una serie de funciones básicas comunes a todas las clases: Œ SXEOLF ERROHDQ HTXDOV 2EMHFW REM . no aparece la cláusula H[WHQGV. Java considera que dicha clase desciende directamente de 2EMHFW. Si al definir una nueva clase. para averiguar el número favorito de un 3DGUH. ¿no?). ) /$ &/$6( 2%-(&7 La clase 2EMHFW es la superclase de todas las clases da Java. directa o indirectamente de ella. ni su edad (sería una indiscreción. pero de ninguna manera podrá conocer ni su saldo.

Devuelve WUXH si el objeto que recibe por parámetro es igual. que el objeto desde el que se llama al método. Si se desean comparar dos referencias a objeto se pueden utilizar los operadores de comparación == y !=.: Se utiliza para comparar. en valor. dos objetos. en valor. SXEOLF LQW KDVK&RGH .

SURWHFWHG 2EMHFW FORQH .: Devuelve un código hash para ese objeto. para poder almacenarlo en una +DVKWDEOH.

WKURZV &ORQH1RW6XSSRUWHG([FHSWLRQ Devuelve una copia de ese objeto.

Œ Œ

Página 72 de 189

Guía de iniciación al lenguaje Java. Versión 2.0. Octubre de 1999

Œ Œ

SXEOLF ILQDO &ODVV JHW&ODVV

: Devuelve el objeto concreto, de tipo &ODVV, que representa la clase de ese objeto. SURWHFWHG YRLG ILQDOL]H

Para más información véase >$UQROG \ *RVOLQJ @. WKURZV 7URZDEOH: Realiza acciones durante la recogida de basura. Página 73 de 189 .

como conceptos que se pueden programar en Java.21(6 $9$1=$'$6 (1 /$6 &/$6(6 $ .1752'8&&.0.Ï1 La programación orientada a objetos en Java va mucho más allá de las clases.$ D.. los objetos y la herencia. Octubre de 1999 . polimorfismo y composición. Versión 2. 23(5$&.Guía de iniciación al lenguaje Java. Java presenta una serie de capacidades que enriquecen el modelo de objetos que se puede representar en un programa Java. % 23(5$&.21(6 $9$1=$'$6 (1 /$ +(5(1&. En este capítulo entraremos en ellos. Vamos a ver cómo programar conceptos avanzados de la herencia.

el lenguaje tiene muchas más posibilidades en este aspecto. Conviene recordar que estamos utilizando el código de la clase 0L3XQWR. Sin embargo..QWURGXFFLyQ En el capítulo anterior ya se han estudiado los fundamentos de la herencia en Java. E. . como estudiaremos a continuación. &ODVHV \ 2EMHWRV´ de este tutorial. cuyo código se puede encontrar en el apartado ³.

de una manera global a un programa. todas las instancias de una clase además del espacio propio para variables de instancia. comparten un espacio común. Por ejemplo: static int a = 3. Otro aspecto en el que es útil VWDWLF es en la creación de métodos a los que se puede llamar directamente diciendo el nombre de la clase en la que están declarados. Esto es útil para modelizar casos de la vida real. es decir. Página 74 de 189 . Todo lo que se tiene que hacer es declarar estos elementos como VWDWLF Esta es la manera que tiene Java de implementar funciones y variables globales. Mediante atributos estáticos. Se puede llamar a cualquier método VWDWLF. sin necesidad de crear un objeto de ese tipo: class ClaseStatic { int atribNoStatic = 42. o referirse a cualquier variable VWDWLF utilizando el operador punto con el nombre de la clase. /RV HOHPHQWRV JOREDOHV VWDWLF A veces se desea crear un método o una variable que se utiliza fuera del contexto de cualquier instancia. static int atribStatic = 99. static void metodoGlobal() { // implementación del método } No se puede hacer referencia a WKLV o a VXSHU dentro de una método VWDWLF.

metodoStatic().out. ClaseStatic. System. static = “ + atribStatic).metodoNoStatic().0. static = 99 Met. // Hace falta instancia Si ejecutamos este programa obtendríamos: At. F.atribStatic). } static void metodoNoStatic() { System. Octubre de 1999 static void metodoStatic() { System.out.println(“Met.Guía de iniciación al lenguaje Java. static = 99 Met. por haber sido declarados VWDWLF. no static = 42 Debe tenerse en cuenta que en un método estático tan sólo puede hacerse refernecia a variables estáticas. // Sin instancia new ClaseStatic(). Versión 2.out. static = “ + ClaseStatic. no static = “ + atribNoStatic). sin QHZ).println(“At. } } El siguiente código es capaz de llamar a PHWRGR6WDWLF y DWULE6WDWLF nombrando directamente la clase (sin objeto.println(“Met.

println(“En el metodo concreto de claseA”). Por último se pueden declarar constructores DEVWUDFW o métodos DEVWUDFW VWDWLF.out. y no se podrán crear instancias de dicha clase (operador QHZ). Cualquier subclase de una clase DEVWUDFW debe implementar todos los métodos DEVWUDFW de la superclase o bien ser declarada también como DEVWUDFW Cualquier clase que contenga métodos declarados como DEVWUDFW también se tiene que declarar como DEVWUDFW. utilizando el modificador de tipo DEVWUDFW A estos métodos también se les llama UHVSRQVDELOLGDG GH VXEFODVH. /DV FODVHV \ PpWRGRV DEVWUDFWRV DEVWUDFW Hay situaciones en las que se necesita definir una clase que represente un concepto abstracto. y por lo tanto no se pueda proporcionar una implementación completa de algunos de sus métodos. } } class claseB extends claseA { void metodoAbstracto(){ Página 75 de 189 . Se puede declarar que ciertos métodos han de ser sobrescritos en las subclases. void metodoConcreto() { System. Veamos un ejemplo de clases abstractas: abstract class claseA { abstract void metodoAbstracto().

println(“En el metodo abstracto de claseB”).0.Guía de iniciación al lenguaje Java. Octubre de 1999 System.out. } } La clase abstracta FODVH$ ha implementado el método concreto PHWRGR&RQFUHWR . Versión 2.

. pero el método PHWRGR$EVWUDFWR .

era abstracto y por eso ha tenido que ser redefinido en la clase hija FODVH%.602 D. La salida de la ejecución del programa es: En el metodo abstracto de claseB En el metodo concreto de claseA & (/ 32/.025).metodoAbstracto(). referenciaA.metodoConcreto(). referenciaA. claseA referenciaA = new claseB().

Al llamar al método PHWRGR'LQDPLFR . } } Por lo tanto si ejecutamos: claseAA referenciaAA = new claseBB(). La salida de este programa es: En el metodo dinamico de clase%% Se declara la variable de tipo FODVH$.out.println(“En el metodo dinamico de claseBB”). y después se almacena una referencia a una instancia de la clase FODVH% en ella. referenciaAA.metodoDinamico().println(“En el metodo dinamico de claseAA”).out. 6HOHFFLyQ GLQiPLFD GH PpWRGR Las dos clases implementadas a continuación tienen una relación subclase/superclase simple con un único método que se sobrescribe en la subclase: class claseAA { void metodoDinamico() { System. } } class claseBB extends claseAA { void metodoDinamico() { System.

de FODVH$. el compilador de Java verifica que FODVH$ tiene un método llamado PHWRGR'LQDPLFR .

pero el intérprete de Java observa que la referencia es realmente una instancia de FODVH%.. por lo que llama al método PHWRGR'LQDPLFR .

Página 76 de 189 . de FODVH% en vez de al de FODVH$.

Guía de iniciación al lenguaje Java. Octubre de 1999 Esta forma de SROLPRUILVPR GLQiPLFR HQ WLHPSR GH HMHFXFLyQ es uno de los mecanismos más poderosos que ofrece el diseño orientado a objetos para soportar la reutilización del código y la robustez.0. E. Versión 2.

en una herencia entre una clase 6HU9LYR y una clase hija 3HUVRQD. A esta modificación de funcionalidad se le llama sobrescritura de un método. 6REUHVFULWXUD GH XQ PpWRGR Durante una jerarquía de herencia puede interesar volver a escribir el cuerpo de un método. para realizar una funcionalidad de diferente manera dependiendo del nivel de abstracción en que nos encontremos. si la clase 6HU9LYR tuviese un método DOLPHQWDUVH . Por ejemplo.

1).distancia(pX.distancia(pX. retorno += ((y/z)-pY)*((y/z)-pY). no a la clase en la cual se está ejecutando el método actual.4). double distancia(int pX. puesto que una persona no se alimenta ni como un $QLPDO. MiPunto p4 = new MiPunto3D(2. debería volver a escribirse en el nivel de 3HUVRQD. A continuación se puede observar la implementación de la sobrecarga de la distancia en 3D y la sobrescritura de la distancia en 2D. ni como una 3ODQWD. La mejor manera de observar la diferencia entre sobrescritura y sobrecarga es mediante un ejemplo.pY) //Método MiPunto3D.distancia(3. A esto se le llama VHOHFFLyQ GLQiPLFD GH PpWRGR.y.. //Método MiPunto. } } Se inician los objetos mediante las sentencias: MiPunto p3 = new MiPunto(1.3).sqrt( retorno ). Y llamando a los métodos de la siguiente forma: p3. retorno += ((x/z)-pX)*((x/z)-pX). class MiPunto3D extends MiPunto { int x.2).. p4.distancia(4.z.. F. int pY) { // Sobrescritura int retorno=0.pY) Los métodos se seleccionan en función del tipo de la instancia en tiempo de ejecución. return Math.

el crear constructores alternativos en función de las coordenadas. 6REUHFDUJD GH PpWRGR Es posible que necesitemos crear más de un método con el mismo nombre. La sobrecarga de método se utiliza para proporcionar a Java un comportamiento SROLPyUILFR Un ejemplo de uso de la sobrecarga es por ejemplo. tal y como se hacía en la clase 0L3XQWR: MiPunto( ) { //Constructor por defecto Página 77 de 189 . pero con listas de parámetros distintas. A esto se le llama VREUHFDUJD GHO PpWRGR.

0. // Constructor por defecto MiPunto p2 = new MiPunto( 5. Octubre de 1999 inicia( -1. no se consideran los nombres de los parámetros formales sino sus tipos: MiPunto p1 = new MiPunto(). 6 ). -1 ). int paramY ) { // Parametrizado this. Java utiliza estas signaturas de tipo para decidir a qué método llamar. // Constructor parametrizado G. Para distinguir entre dos métodos. Versión 2.x = paramX. y = paramY. Al número de parámetros con tipo de una secuencia específica se le llama VLJQDWXUD GH WLSR.Guía de iniciación al lenguaje Java. } Se llama a los constructores basándose en el número y tipo de parámetros que se les pase. } MiPunto( int paramX.

/LPLWDFLyQ GH OD VREUHHVFULWXUD ILQDO Todos los métodos y las variables de instancia se pueden sobrescribir por defecto. ' /$6 5()(5(1&.6 < 683(5 E. éstos se pueden declarar como final.&$6 7+. Es un convenio de codificación habitual elegir identificadores en mayúsculas para las variables que sean ILQDO por ejemplo: final int NUEVO_ARCHIVO = 1. Esto se utiliza a menudo para crear el equivalente de una constante de C++.0Ï5). Si se desea declarar que ya no se quiere permitir que las subclases sobrescriban las variables o métodos.$6 32/.

también vale para sustituir a sus constructores. int paramY ).. también se la puede nombrar como ejemplo de polimorfismo Además de hacer continua referencia a la clase en la que se invoque. utilizándola como método: this(). $FFHVR D OD SURSLD FODVH WKLV Aunque ya se explicó en el apartado . // Constructor parametrizado E. // Constructor por defecto this( int paramX. &ODVHV \ REMHWRV de este tutorial el uso de la referencia WKLV como modificador de ámbito.

La referencia VXSHU usa para acceder a métodos o atributos de la superclase. En Java existe otra referencia llamada VXSHU. Podíamos haber implementado el constructor de la clase 0L3XQWR' (hija de 0L3XQWR) de la siguiente forma: MiPunto3D( int x. int z ) { Página 78 de 189 . int y. que se refiere directamente a la superclase. $FFHVR D OD VXSHUFODVH VXSHU Ya hemos visto el funcionamiento de la referencia WKLV como referencia de un objeto hacia sí mismo.

y ). // Aquí se llama al constructor de MiPunto this.0.metodoSuma( x. y ).z = super. Octubre de 1999 super( x.Guía de iniciación al lenguaje Java. // Método de la superclase } Con una sentencia VXSHUPHWRGR6XPD [ \. Versión 2.

se llamaría al método PHWRGR6XPD .

Por el contrario con VXSHU . de la superclase de la instancia WKLV.

quedaría definida por dos objetos de la clase 0L3XQWR.Ï1 Otro tipo de relación muy habitual en los diseños de los programas es la composición.y<=extremo2. instanciando un objeto para cada una en el constructor. //extremo inferior izquierdo MiPunto extremo2.y>=extremo1. extremo2=new MiPunto(). La forma de implementar una relación de composición en Java es incluyendo una referencia a objeto de la clase componedora en la clase compuesta. Por ejemplo.x>=extremo1. ( /$ &20326.y ) return true. else return false. establece unos límites de su área. un coche es un conjunto de motor y carrocería. que representasen dos puntas contrarias de un rectángulo: class AreaRectangular { MiPunto extremo1. llamamos al constructor de la superclase. y así sucesivamente. } } ) Puede observarse que las referencias a objeto (H[WUHPR y H[WUHPR) son iniciadas. Los objetos suelen estar compuestos de conjuntos de objetos más pequeños.&. que serán utilizados para comprobar si un punto está en su área en el método HVWD(Q(O$UHD . } boolean estaEnElArea( MiPunto p ){ if ( ( p. una clase $UHD5HFWDQJXODU.y && p. referenciados por H[WUHPR y H[WUHPR. un motor es un conjunto de piezas.x ) && ( p.x<=extremo2. Así esta clase mediante dos puntos. Este concepto es lo que se conoce como FRPSRVLFLyQ. //extremo superior derecho AreaRectangular() { extremo1=new MiPunto().x && p.

Página 79 de 189 ..

Object Throwable Exception Clases de Exception RuntimeException Clases de RuntimeException Error Clases de Error . que está incluida en el paquete MDYDODQJ. Pero Java va mucho más allá.Ï1 El control de flujo en un programa Java puede hacerse mediante las ya conocidas sentencias estructuradas (LI ZKLOH UHWXUQ).&(3&.. Durante este capítulo estudiaremos la gestión de excepciones y errores.0. % 7. 5XQWLPH([FHSWLRQ: Excepciones que se dan durante la ejecución del programa. mediante una técnica de programación denominada JHVWLyQ GH H[FHSFLRQHV.21(6 < (5525(6 $ .Ï1 '( (.&(3&.326 '( (. y avisar a otros objetos de una condición anormal de ejecución durante un programa. *(67. ([FHSWLRQ: Excepciones no definitivas. sin pretender profundizar demasiado.Guía de iniciación al lenguaje Java. Mediante la gestión de excepciones se prescindirá de sentencias de control de errores del tipo: if ( error == true ) return ERROR. Versión 2.PDJHQ  +HUHQFLD GH H[FHSFLRQHV -DYD Todas las excepciones tienen como clase base la clase 7KURZDEOH. Mediante las excepciones se podrá evitar repetir continuamente código.1752'8&&. que suelen ser no recuperables y no deben casi nunca ser capturadas. Octubre de 1999 . pero que se detectan fuera del tiempo de ejecución. pero sí fijando la base conceptual de lo que este modo de programación supone. y sus métodos son: Œ Œ Œ 7URZDEOH 6WULQJ PHQVDMH .21(6 Existen varios tipos fundamentales de excepciones: Œ Œ Œ Error: Excepciones que indican problemas muy graves. en busca de un posible error.

 Constructor. La cadena es opcional 7KURZDEOH ILOO.Q6WDFN7UDFH .

6WULQJ JHW/RFDOL]HG0HVVDJH . Llena la pila de traza de ejecución.

Página 80 de 189 . Crea una descripción local de este objeto.

0.Guía de iniciación al lenguaje Java. Octubre de 1999 Œ Œ Œ 6WULQJ JHW0HVVDJH . Versión 2.

YRLG SULQW6WDFN7UDFH 3ULQW6WUHDPBRB3ULQW:ULWHU V. Devuelve la cadena de error del objeto.

o en la salida estándar (por defecto). 6WULQJ WR6WULQJ . Imprime este objeto y su traza en el flujo del parámetro s.

 Devuelve una breve descripción del objeto.21$0. & )81&.(172 D.

E. y actuar en consecuencia. Comprobar en ciertas partes de los programas si una excepción se ha producido. Para ello se utilizan las palabras reservadas throw y throws. . Para ello se utilizan las palabras reservadas try. catch y finally.QWURGXFFLyQ Para que el sistema de gestión de excepciones funcione. se ha de trabajar en dos partes de los programas: Œ Œ Definir qué partes de los programas crean una excepción y bajo qué condiciones.

puesto que cualquier clase hija de 5XQWLPH es también hija de 7KURZDEOH. por herencia. en las que se especifica que acción realizar: try { // Código posiblemente problemático } catch( tipo_de_excepcion e) { // Código para solucionar la excepción e } catch( tipo_de_excepcion_mas_general e) { // Código para solucionar la excepción e } En el ejemplo se observa que se pueden anidar sentencias FDWFK. porque el intérprete Java ejecutará aquel bloque de código FDWFK cuyo parámetro sea del tipo de una excepción lanzada. pero conviene hacerlo indicando en último lugar las excepciones más generales (es decir. nunca llegaríamos a gestionar una excepción 5XQWLPH. Si por ejemplo se intentase capturar primero una excepción 7KURZDEOH. que se encuentren más arriba en el árbol de herencia de excepciones). Página 81 de 189 . Si no se ha lanzado ninguna excepción el código continúa sin ejecutar ninguna sentencia FDWFK. debe incluir este fragmento de código dentro de un bloque WU\: try { // Código posiblemente problemático } Pero lo importante es cómo controlar qué hacer con la posible excepción que se cree. una lectura en un fichero). 0DQHMR GH H[FHSFLRQHV WU\  FDWFK  ILQDOO\ Cuando el programador va a ejecutar un trozo de código que pueda provocar una excepción (por ejemplo. Para ello se utilizan las clausulas FDWFK.

Versión 2. Este código se ejecutará tanto si se ha tratado una excepción (FDWFK) como sino. Para insertar fragmentos de código que se ejecuten tras la gestión de las excepciones.Guía de iniciación al lenguaje Java. ¿y si quiero realizar una acción común a todas las opciones?.0. que será ejecutada tras el bloque WU\ o FDWFK try { } catch( Exception e ) { } finally { // Se ejecutara tras try o catch } F. Este tipo de código se inserta en una sentencia ILQDOO\. Octubre de 1999 Pero.

Para ello se utiliza la sentencia WKURZV: tipo_devuelto miMetodoLanzador() throws miExcep1. Aquellos métodos que pueden lanzar excepciones. Por una parte la excepción se lanza mediante la sentencia WKURZ: if ( condicion_de_excepcion == true ) throw new miExcepcion(). puesto que las excepciones son objetos y por tanto deberán ser instanciadas antes de ser lanzadas. Para ello se utilizan las palabras reservadas WKURZ y WKURZV. miExcep2 { // Codigo capaz de lanzar excepciones miExcep1 y miExcep2 } Se puede observar que cuando se pueden lanzar en el método más de una excepción se deben indicar en su declaración separadas por comas. /DQ]DPLHQWR GH H[FHSFLRQHV WKURZ  WKURZV Muchas veces el programador dentro de un determinado método deberá comprobar si alguna condición de excepción se cumple. G. deben cuáles son esas excepciones en su declaración. y si es así lanzarla. Se puede observar que hemos creado un objeto de la clase PL([FHSFLRQ.

de Exception } } // Esta clase lanzará la excepción Página 82 de 189 . (MHPSOR GH JHVWLyQ GH H[FHSFLRQHV Ahora que ya sabemos cómo funciona este sistema. conviene ver al menos un pequeño ejemplo. // constructor por defecto de Exception } MiExcepcion( String cadena ){ super( cadena ). // constructor param. que ilustre al lector en el uso de las excepciones: // Creo una excepción personalizada class MiExcepcion extends Exception { MiExcepcion(){ super().

close(). } catch ( MiExcepcion e ){ // Personalizada System.out. } catch ( IOException e ){ // Estándar System. int leo.0.println( "Todo fue bien" ).println( "Excepcion: " + e.read() ) != -1 ) lanza. } finally { if ( entrada != null ) try { entrada. FileInputStream entrada = null.println( "Excepcion: " + e. try { entrada = new FileInputStream( "fich.txt" ).Guía de iniciación al lenguaje Java.getMessage() ). } } } class Excepciones { public static void main( String[] args ) { // Para leer un fichero FileInputStream entrada = null. // Siempre queda cerrado } catch ( Exception e ) { System. entrada.getMessage() ). } System. Página 83 de 189 .getMessage() ). while ( ( leo = entrada.println( "Excepcion: " + e.out.out.println( "Fichero cerrado." ).close(). System.lanzaSiNegativo( leo ). Octubre de 1999 class Lanzadora { void lanzaSiNegativo( int param ) throws MiExcepcion { if ( param < 0 ) throw new MiExcepcion( "Numero negativo" ). } } class Excepciones { public static void main( String[] args ) { // Para leer un fichero Lanzadora lanza = new Lanzadora().out. Versión 2.out.

0.lanzaSiNegativo( leo ). while ( ( leo = entrada. // Así el fichero siempre queda cerrado System.io. al leer el primer número.println( "Excepcion: " + e. } catch ( MiExcepcion e ){ // Personalizada System. try { entrada = new FileInputStream("fich. Si alguno de los números leídos es negativo.println( "Excepcion: " + e.read() ) != -1 ) lanza. } } } Este programa lee un fichero (ILFKHURW[W). Además gestiona la excepción .txt"). La salida de este programa.close().2([FHSWLRQ. } finally { entrada.println( "Todo fue bien" ).out. sería: Excepcion: java. Versión 2.println( "Fichero cerrado" ).getMessage() ).IOException Fichero cerrado H.out. int leo. Ambas excepciones son gestionadas.getMessage() ). } catch ( IOException e ){ // Estándar System.out. que es una excepción de las que Java incluye y que se lanza si hay algún problema en una operación de entrada/salida.Guía de iniciación al lenguaje Java. System. lanza una excepción 0L([FHSFLRQ. suponiendo un número negativo sería: Excepcion: Numero negativo Fichero cerrado En el caso de que no hubiera ningún número negativo sería: Todo fue bien Fichero cerrado En el caso de que se produjese un error de E/S. Octubre de 1999 Lanzadora lanza = new Lanzadora().out. imprimiendo su contenido (cadena de error) por pantalla. y lee su contenido en forma de números.

&RQFOXVLRQHV En cualquier caso se recomienda al programador no abusar de este sistema como control de flujos simples. véanse >=ROOL @ y >1DXJKWRQ @ Página 84 de 189 . sino utilizarlo sólo en aquellos estados del programa que realmente creen un problema de ejecución que pueda ser letal para el programa. Para más información sobre las excepciones Java.

Guía de iniciación al lenguaje Java.21(6 48( .0.&(3&. Versión 2. Octubre de 1999 ' (.1&25325$ -$9$  D.

QFRPSDWLEOH&ODVV&KDQJH(UURU: En una clase. 1R&ODVV'HI)RXQG(UURU: No se encontró una clase cuando se necesitaba. 1R6XFK)LHOG(UURU: No se encontró determinado atributo. Œ Œ Œ Œ &ODVV&LUFXODULW\(UURU: Se detectó una herencia circular entre clases. 7KUHDG'HDWK: Se ha lanzado en el WKUHDG víctima tras llamar a VWRS .QLWLDOL]HU(UURU: Error al iniciar un miembro static. . 1R6XFK0HWKRG(UURU: No se encontró determinado método.Q.QVWDQWLDWLRQ(UURU: Se intentó instanciar una clase abstracta o interfaz. Œ 8QVXSSRUWHG&ODVV9HUVLRQ(UURU: La versión de una clase no es correcta. . . ([FHSWLRQ. &ODVV)RUPDW(UURU: Una clase cargada no ha sido incompletamente descrita. 9HULI\(UURU: Se ha producido un error de verificación al cargar una clase. &ODVHV GH (UURU /LQNDJH(UURU: Una clase no satisface la dependencia que tiene respecto a otra.OOHJDO$FFHVV(UURU: La aplicación intentó acceder a algún miembro no visible. 8QVDWLVILHG/LQN(UURU: Se encontró un enlace insatisfecho en un método nativo. su interfaz no es igual al declarado Œ Œ Œ Œ Œ Œ Œ Œ $EVWUDFW0HWKRG(UURU: Se ha invocado un método abstracto.

E. 8QNQRZQ(UURU: Grave error desconocido. 6WDFN2YHUIORZ(UURU: Desbordamiento de pila. Œ Œ Œ Œ . 2XW2I0HPRU\(UURU: El lector ha agotado la memoria. ¿Recursión infinita?..QWHUQDO(UURU: Error interno en tiempo de ejecución. 9LUWXDO0DFKLQH(UURU: La máquina virtual se ha averiado o quedado sin recursos.

.OOHJDO$FFHVV([FHSWLRQ: Algún método invocado es no visible.QVWDQWLDWLRQ([FHSWLRQ: Se ha intentado instanciar una interfaz o una clase abstracta.QWHUUXSWHG([FHSWLRQ: Cuando se invoca a LQWHUUXSW . &ODVHV GH ([FHSWLRQ &ORQH1RW6XSSRUWHG([FHSWLRQ: No se pudo copiar un objeto mediante clone(). . .

1R6XFK0HWKRG([FHSWLRQ: La clase no tiene un método con ese nombre. F. 1R6XFK)LHOG([FHSWLRQ: La clase no tiene un atributo con ese nombre. sobre un WKUHDG dormido.

. &ODVHV GH 5XQWLPH([FHSWLRQ $ULWKPHWLF([FHSWLRQ: Error de cálculo (como división por cero. &ODVV&DVW([FHSWLRQ: Intento de conversión inválida. .OOHJDO$UJXPHQW([FHSWLRQ: Se ha pasado un argumento inválido a un método: Página 85 de 189 .).. $UUD\6WRUH([FHSWLRQ: Intento de almacenar un objeto equivocado en un vector.

1HJDWLYH$UUD\6L]H([FHSWLRQ: Intento de creación de un vector de tamaño negativo. 1XOO3RLQWHU([FHSWLRQ: Se ha usado una referencia QXOO para acceder a un campo. 8QVXSSRUWHG2SHUDWLRQ([FHSWLRQ: Una operación invocada no se soporta.QGH[2XW2I%RXQGV([FHSWLRQ: Acceso a un vector fuera de sus límites: Œ Œ $UUD\. 6HFXULW\([FHSWLRQ: Algo ha sido vedado por el sistema de seguridad. para una cadena.QGH[2XW2I%RXQGV([FHSWLRQ: Idem.QGH[2XW2I%RXQGV([FHSWLRQ: Idem. . Para más información véase la documentación del JDK que usted vaya a utilizar. Página 86 de 189 . . Versión 2. no lo contiene.0.OOHJDO6WDWH([FHSWLRQ: Método invocado en un momento inapropiado. 6WULQJ.OOHJDO0RQLWRU6WDWH([FHSWLRQ: Se ha usado ZDLWQRWLI\ fuera de código sincronizado.Guía de iniciación al lenguaje Java. 1XPEHU)RUPDW([FHSWLRQ: Una cadena contenedora de un número. para una matriz. .OOHJDO7KUHDG6WDWH([FHSWLRQ: Un thread no estaba en el estado adecuado. Octubre de 1999 Œ Œ .

pero sin desarrollar un mecanismo de solución..0.03/(0(17$&.17(5)$= Como ya se ha visto. Por su parte. que asume las constantes de la interfaz.1752'8&&. y ser acelerada convenientemente en la versión definitiva tras conocer más a fondo el problema. por lo que se necesita algún mecanismo para dar cuerpo a sus métodos. . por tanto. las interfaces carecen de funcionalidad por no estar implementados sus métodos. Por ejemplo una misma interfaz podría ser implementada en una versión de prueba de manera poco óptima.Guía de iniciación al lenguaje Java. métodos sin implementación & . Versión 2. pues en realidad actuarán como constantes ILQDO. % '(&/$5$&. } Se observa en la declaración que las variables adoptan la declaración en mayúsculas. de la misma manera que se usa la sentencia FODVV: interface MiInterfaz { int CONSTANTE = 100. int metodoAbstracto( int parametro ){ return ( parametro * multiplicando ). int metodoAbstracto( int parametro ). y codifica sus métodos: class ImplementaInterfaz implements MiInterfaz{ int multiplicando=CONSTANTE. Octubre de 1999 . La palabra reservada LPSOHPHQWV utilizada en la declaración de una clase indica que la clase implementa la interfaz. en lugar de su cuerpo entre llaves. En ningún caso estas variables actuarán como variables de instancia. Se trata de auténticas conceptualizaciones no implementadas que sirven de guía para definir un determinado concepto (clase) y lo que debe hacer.17(5)$&(6 $ . } } Página 87 de 189 . Se trata de declarar métodos abstractos y constantes que posteriormente puedan ser implementados de diferentes maneras según las necesidades de un programa. Son métodos abstractos.Ï1 Para declarar una interfaz se utiliza la sentencia LQWHUIDFH. los métodos tras su declaración presentan un punto y coma.Ï1 '( 81$ .Ï1 Las interfaces Java son expresiones puras de diseño. es decir.

Guía de iniciación al lenguaje Java.0. Octubre de 1999 En este ejemplo se observa que han de codificarse todos los métodos que determina la interfaz (mHWRGR$EVWUDFWR . Versión 2.

$ 0Ò/7. interface InterfazMultiple extends Interfaz1.3/( En una herencia múltiple. pero puede implementar más de una interfaz: class MiClase extends SuPadre implements Interfaz1. y la validez de las constantes (&2167$17() que define la interfaz durante toda la declaración de la clase. si dos de las interfaces padres tienen algún método o atributo que coincida en nombre. Una interfaz puede heredar de más de una interfaz antecesora. Esto se dará cuando las clases padre (en el ejemplo anterior % y &) tienen un atributo o método que se llame igual. los identificadores de algunos métodos o atributos pueden coincidir en la clase que hereda.3/( Java es un lenguaje que incorpora herencia simple de implementación pero que puede aportar herencia múltiple de interfaz.PDJHQ  (MHPSOR GH KHUHQFLD P~OWLSOH Para poder llevar a cabo un esquema como el anterior en Java es necesario que las clases A.$ 0Ò/7. Esto posibilita la herencia múltiple en el diseño de los programas Java. Para la colisión de nombres de atributos.). aunque sí extenderla (H[WHQGV) ampliándola. Java resuelve el problema estableciendo una serie de reglas.Interfaz2{ } El ejemplo típico de herencia múltiple es el que se presenta con la herencia en diamante: . B y C de la figura sean interfaces. Página 88 de 189 . se obliga a especificar a qué interfaz base pertenecen al utilizarlos.6.Interfaz2{ } Una clase no puede tener más que una clase antecesora. y que la clase D sea una clase (que recibe la herencia múltiple): interface A{ } interface B extends A{ } interface C extends A{ } class D implements B.C{ } ( &2/. ' +(5(1&.21(6 (1 /$ +(5(1&. Una interfaz no puede implementar otra interfaz. A esto se le llama FROLVLyQ.

indicando que no se pueden implementar los dos. Versión 2. Octubre de 1999 Para la colisión de nombres en métodos: Œ Œ Œ Si tienen el mismo nombre y diferentes parámetros: se produce sobrecarga de métodos permitiendo que existan varias maneras de llamar al mismo. short y byte. A estas interfaces se las conoce como HQYROWXUDV GH WLSR VLPSOH. Página 89 de 189 . Si coinciden en su declaración: se elimina uno de los dos. consúltese >1DXJKWRQ @. Para más información sobre as envolturas de tipos simples. La API de Java contiene un conjunto de interfaces especiales para modificar el comportamiento de los tipos de datos simple. Sin embargo a veces es necesario crear una representación como objeto de alguno de los tipos de datos simples de Java.03/(6 Los tipos de datos de Java no forman parte de la jerarquía de objetos.Guía de iniciación al lenguaje Java. &KDUDFWHU: Envoltura del tipo char. Si sólo cambia el valor devuelto: se da un error de compilación.0. /RQJ: Da soporte al tipo long. Todas ellas son hijas de la clase abstracta 1XPEHU y son: Œ Œ Œ Œ Œ Œ 'RXEOH: Da soporte al tipo double. . ) (192/785$6 '( /26 7. con lo que sólo queda uno. )ORDW: Da soporte al tipo float. %RROHDQ: Envoltorio al tipo boolean.QWHJHU: Da soporte a los tipos int.326 6.

Con la idea de mantener la reutilización y facilidad de uso de los paquetes desarrollados es conveniente que las clases e interfaces contenidas en los mismos tengan cierta relación funcional. Octubre de 1999 . se agrupan conjuntos de estructuras de datos y de clases con algún tipo de relación en común..1752'8&&.Guía de iniciación al lenguaje Java. % &5($&.Ï1 Los paquetes son el mecanismo por el que Java permite agrupar clases. Versión 2. De esta manera los desarrolladores ya tendrán una idea de lo que están buscando y fácilmente sabrán qué pueden encontrar dentro de un paquete. interfaces. excepciones y constantes. De esta forma. 3$48(7(6 $ .Ï1 '( 81 3$48(7( D.0.

Las clases privadas del paquete (opcional). La estructura que ha de seguir un fichero fuente en Java es: Œ Œ Œ Œ Una única sentencia de paquete (opcional). E. Las sentencias de importación deseadas (opcional). 'HFODUDFLyQ Para declarar un paquete se utiliza la sentencia SDFNDJH seguida del nombre del paquete que estemos creando: package NombrePaquete. La declaración de una (y sólo una) clase pública (SXEOLF). Por lo tanto la sentencia de declaración de paquete ha de ser la primera en un archivo fuente Java.

Por eso se propone asignar como paquetes y subpaquetes el nombre de dominio dentro de Internet. y absolutamente imposible dentro de la comunidad de Internet. Esto puede ser una tarea realmente tediosa dentro de una gran empresa. Se verá un ejemplo para un dominio que se llamase MDSRQPDJLFFRP un nombre apropiado sería FRPPDJLFMDSRQSDTXHWH. F. 1RPHQFODWXUD Para que los nombres de paquete puedan ser fácilmente reutilizados en toda una compañía o incluso en todo el mundo es conveniente darles nombres únicos.

de forma que un programador probablemente estará interesado en organizar sus paquetes de forma jerárquica. Para eso se definen los VXESDTXHWHV Para crear un subpaquete bastará con almacenar el paquete hijo en un directorio 3DTXHWH6XESDTXHWH Página 90 de 189 . 6XESDTXHWHV Cada paquete puede tener a su vez paquetes con contenidos parecidos.

Se pueden importar todos los elementos de un paquete o sólo algunos.Clase_o_Interfaz.Subpaquetes1. -'. surge la duda de cómo proteger los elementos de una clase. Por defecto se considera los elementos (clases.Subpaquete1.0. El directorio actual suele estar siempre incluido en la variable de entorno &/$663$7+. El JDK define una variable de entorno denominada &/$663$7+ que gestiona las rutas en las que el JDK busca los subpaquetes.Subpaquete2.Guía de iniciación al lenguaje Java. de este tutorial.Subpaquete2.72 '( /26 (/(0(1726 '( 81 3$48(7( Al introducir el concepto de paquete. sino que basta con referenciar el elemento tras una especificación completa de la ruta de paquetes y subpaquetes en que se encuentra. Ya en la herencia se vieron los identificadores de visibilidad SXEOLF (visible a todas las clases).*. También existe la posibilidad de que se deseen importar sólo algunas de las clases de un cierto paquete o subpaquete: import Paquete.elemento En la API de Java se incluyen un conjunto de paquetes ya desarrollados que se pueden incluir en cualquier aplicación (o DSSOHW) Java que se desarrolle..Clase1. no es necesario importar explícitamente el paquete en que aparecen. Octubre de 1999 Así una clase dentro de un VXESDTXHWH como 3DTXHWH6XESDTXHWHFODVH estará codificada en el fichero 3DTXHWH6XESDTXHWHMDYD.. GH -DYD" de este tutorial. Para más información sobre el JDK véase el $SpQGLFH . variables y métodos) de un mismo paquete como visibles entre ellos (supliendo las denominadas FODVHV DPLJDV de C++). Para acceder a los elementos de un paquete.. Versión 2. & 862 '( 81 3$48(7( Con el fin de importar paquetes ya desarrollados se utiliza la sentencia LPSRUW seguida del nombre de paquete o paquetes a importar. Para importar todas las clases e interfaces de un paquete se utiliza el metacaracter : import PaquetePrueba. ' È0%. Estos paquetes son explicados con más detalle en el capítulo ". SULYDWH (no visible más que para la propia clase). y SURWHFWHG (visible a clases hijas). respecto a los de otros paquetes. Paquete.%LEOLRWHFDV GH OD $3. qué visibilidad presentan respecto al resto de elementos del paquete.. 6LWXDFLyQ GHO HOHPHQWR (Q XQD FODVH No Sí Sí HQ HO PLVPR SDTXHWH (Q XQD FODVH KLMD No No Sí HQ RWUR SDTXHWH (Q XQD FODVH QR KLMD No No No HQ RWUR SDTXHWH 7DEOD  9LVLELOLGDG GHQWUR GH XQ SDTXHWH (Q OD PLVPD FODVH SULYDWH Sí VLQ PRGLILFDGRU Sí SURWHFWHG Sí SXEOLF Sí Sí Sí Sí Página 91 de 189 .

Para más información véase >1DXJKWRQ @ Página 92 de 189 .0. Octubre de 1999 Todas las reglas explicadas en este apartado son igualmente válidas para las interfaces Java. Versión 2.Guía de iniciación al lenguaje Java.

+.. Java permite que estos tiempos desaprovechados sean utilizados por el programador para realizar determinadas tareas. en busca de una interacción con el exterior. Octubre de 1999 . y crear un objeto de la clase 7KUHDG.1752'8&&. Versión 2. y así aprovechar el microprocesador durante toda la ejecución del programa.Ï1 08/7. que será accionado cuando invoquemos al método VWDUW ./2 $ . Para ello implementa el concepto de WKUHDGV. % 87./.0. extendiendo la clase base 5XQQDEOH. se consigue ejecutar varios procesos en paralelo. esperando a que otro proceso acabe..Guía de iniciación al lenguaje Java. de nuevo se intercambian los WKUHDGV para que el primer WKUHDG continúe su ejecución. extendida entre los programadores de C en UNIX. Mediante el uso de varios WKUHDGV. permita que el microprocesador ejecute alguno de los otros WKUHDGV en espera.Ï1 '( 7+5($' Para crear un WKUHDG. Cuando el evento que el primer WKUHDG esperaba sucede. o hilos de control del programa.Ï1 Durante la ejecución de los programas existen muchas operaciones que precisan de una espera. dejando pasar el tiempo. /26 7+5($'6 2 352*5$0$&. Este objeto representará un nuevo hilo de control. se ha de implementar una clase. de forma que cuando uno de ellos esté esperando algún evento.. Todo esto viene a suplir a la técnica de exclusión mutua denominada XWLOL]DFLyQ GH VHPiIRURV.=$&.

En ese momento este hilo se activará. ejecutando (si el planificador de hilos considera que es el momento). el método UXQ . del WKUHDG.

io. }. }.start().net. "ThDemo" ). public void run() { try { Thread.out. y el hilo WK'HPR que creamos import java. de la clase en que todo esto suceda. el siguiente programa utiliza dos hilos. class ThreadDemo implements Runnable { ThreadDemo() { Thread thDemo = new Thread( this.println("Saliendo del hilo hijo"). public static void main( String args[] ){ Página 93 de 189 .*. System. import java. thDemo.*.sleep(3000). } catch( InterruptedException e ) { }. Por ejemplo. el hilo general PDLQ.

) { System. i >0 . i-.0. Octubre de 1999 new ThreadDemo(). }. try { for ( int i = 5 . Thread.out. } } catch( InterruptedException e ) { }.out. }.sleep(1000). System. Versión 2.Guía de iniciación al lenguaje Java.println(" Seg: " + i ). Ambos hilos esperan utilizando el método VOHHS .println("Saliendo del main").

de la clase 7KUHDG. Para ello en Java se utilizan la palabra reservada V\QFURQL]HG. y PDLQ cinco segundos. WK'HPR tres segundos.1&521. muchas veces varios procesos han de realizar tareas de una forma sincronizada.Ï1 '( 7+5($'6 Durante la ejecución de un programa. en la declaración de los procesos con este tipo de características. Por lo tanto la salida por pantalla al ejecutar el programa es: prompt> java ThreadDemo Seg: 5 Seg: 4 Seg: 3 Saliendo del hilo hijo Seg: 2 Seg: 1 Saliendo del hilo main & 6. actuando en un determinado orden. y de las funciones ZDLW . Los procesos declarados como V\QFURQL]HG mediante la utilización de excepciones.=$&. Java utilizará los tres segundos de WK'HPR para ir esperando los tres primeros segundos del hilo PDLQ.

y QRWLIL\ .

. A continuación se va a ir viendo cómo implementar el clásico problema de exclusión mutua conocido como HO SUREOHPD GHO SURGXFWRUFRQVXPLGRU. synchronized int obten() { Página 94 de 189 . en la que el proceso SURGXFWRU inserta elementos en la pila. y el proceso FRQVXPLGRU ha de ir consumiendo los elementos en la pila. cada vez que sean insertados: class ColaSincronizada { int n. respectivamente esperarán a que otro proceso acabe antes de continuar su ejecución. en el que dos procesos han de acceder a una cola común. boolean bandera = false.

} public void run() { Página 95 de 189 .start().coloca( i++ ).println( "Obtenido: " + n ). n = paramN. catch( InterruptedException e ). return n. } synchronized void coloca( int paramN ) { if ( bandera ) try wait(). catch( InterruptedException e ). new Thread( this. } } class Consumidor implements Runnable { ColaSincronizada colaConsumidor. bandera = false. } } class Productor implements Runnable { ColaSincronizada colaProductor. Octubre de 1999 if ( !bandera ) try wait().Guía de iniciación al lenguaje Java. while ( true ) // Bucle infinito colaProductor. Consumidor( ColaSincronizada paramCola ) { colaConsumidor = paramCola. Versión 2.out. bandera =true. "Consumidor" ).0.println( "Colocado: " + n ). Productor( ColaSincronizada paramCola ) { colaProductor = paramCola. notify(). System. notify().start().out. } public void run() { int i = 0. "Producer" ). System. new Thread( this.

} La salida del programa será: Colocado: 1 Obtenido: 1 Colocado: 2 Obtenido: 2 Colocado: 3 Obtenido: 3 . new Consumidor( colaLocal ). new Productor( colaLocal ). .0. Versión 2.Guía de iniciación al lenguaje Java. Octubre de 1999 while ( true ) // Bucle infinito colaConsumidor.obten( ). Estos métodos son: Œ Œ Œ VXVSHQG . . } } public static void main( String args[] ) { ColaSincronizada colaLocal = new ColaSincronizada(). La utilización de los WKUHDGV se extiende con métodos para que el programador controle la alternancia de los hilos. ' < 08&+2 0È6 La utilización de programación concurrente y de los hilos de Java con toda su potencia va mucho más allá de los objetivos de este tutorial. Lo que aquí se ha visto es simplemente una introducción para que el lector sea consciente de cuál es la potencia de este tipo de programación.

UHVXPH . Bloquea temporalmente la ejecución de un hilo.

 Activa un hilo bloqueado. VWRS .

Página 96 de 189 . Para más información sobre los WKUHDGV véase >=ROOL @. Finaliza la ejecución de un hilo.

0. así como su utilización. Versión 2.Ï1 Una vez entendida la sintaxis y funcionalidad de Java. &5($&. especialmente gracias a la versatilidad de las bibliotecas de clases que completan el Java básico.1752'8&&.326 '( $3/.21(6 D. hay que explicar cómo combinar todos los elementos introducidos para desarrollar programas Java.Guía de iniciación al lenguaje Java.. La programación Java va mucho más allá de lo que la definición del lenguaje permite.&$&. Son muchos los tipos de aplicaciones que se pueden crear con Java.Ï1 '( 352*5$0$6 -$9$ $ . Octubre de 1999 . % 7.

QWURGXFFLyQ Con Java se pueden construir varios tipos de programas. -DYD%HDQV. A continuación se explican los principales tipos: Aplicaciones. Para más información véase >0RUJDQ @ y >=ROOL @. y que se ejecutan de distintas maneras. . $SSOHWV. cada uno con unas características específicas. -DYD6FULSW y 6HUYOHWV. E.

Se ejecutan en una determinada máquina. por el Java Runtime Enviroment (JRE). Para crear una aplicación hace falta incluir en alguna de las clases que compongan la aplicación un método denominado: Œ SXEOLF VWDWLF YRLG PDLQ 6WULQJ>@ V. $SOLFDFLRQHV Son los programas básicos de Java.

que queremos ejecutar.^ ` Hay que indicar al JRE (comando MDYD del JDK) el nombre de la clase (previamente compilada a FODVV). Cuando se ejecute el programa lo que realmente se ejecutará será el método PDLQ .

Las aplicaciones soportan métodos nativos. En cada fichero Java (MDYD) sólo debe haber una clase pública. o sea. de la clase indicada al JRE. incluir en el programa código escrito en otros lenguajes de programación. así como violar algunas de las directrices de seguridad. F.

$SSOHWV Las DSSOHWV o miniaplicaciones Java. son programas que deben incluirse en páginas Web para ser observadas por otra aplicación (visualizador de applets o navegador Web). Las DSSOHWV deben incluir un método de nombre VWDUW . y que se ejecutan cuando el usuario intenta visualizarlas (cargando la página Web).

Estas aplicaciones. son seguras (cumplen la especificación Java). Página 97 de 189 . que será ejecutado cuando el navegador intente mostrar por pantalla la DSSOHW.. y al ser distribuibles por Internet no permiten incluir métodos nativos Java.

Guía de iniciación al lenguaje Java.0. Octubre de 1999 G. Versión 2.

El BDK. que se pueden incorporar a otros componentes gráficos. H. Existe una herramienta de Sun. Existen ya multitud de bibliotecas con -DYD%HDQV. que es un conjunto de herramientas para desarrollar -DYD%HDQV. es el -'. para el desarrollo de -DYD%HDQV. -DYD%HDQV Los -DYD%HDQV son componentes gráficos de Java. para que puedan ser utilizados. Se incluyen en la API de Java (paquete MDYDEHDQV). denominada BDK (Beans Developer Kit).

-DYD6FULSW posee una habilidad limitada para interactuar con applets Java. -DYD6FULSW tiene menos potencia que Java. Se utiliza sobre todo para dar animación e interactividad a páginas Web. pero Java no puede interactuar de ningún modo con -DYD6FULSW. el código fuente de -DYD6FULSW forma parte del propio documento HTML. a cambio de más control sobre el navegador Web que lo ejecute. I. -DYD6FULSW -DYD6FULSW es un subconjunto del lenguaje Java que puede codificarse directamente sobre cualquier documento HTML.

6HUYOHWV Son módulos que permiten sustituir o utilizar el lenguaje Java en lugar de programas CGI (Common Gateway Interface) a la hora de dotar de interactividad a las páginas Web. y normalmente incluyen bucles infinitos a la espera de peticiones a las que atender.Ï1 D. & 5(&20(1'$&. Reciben datos y su respuesta más habitual suele ser código HTML (páginas Web). Los 6HUYOHWV no tienen entorno gráfico. ya que se ejecutan en el servidor.21(6 '( 352*5$0$&. Estas aplicaciones se ejecutan como aplicaciones servidoras en Internet.

sus preferencias de indentación... desde este tutorial se proponen una serie de pautas que ayudarán a que sus programas sean más legibles.QWURGXFFLyQ Es un hecho innegable que cada programador tiene su forma personal de programar. mantenibles y eficientes: E. . En cualquier caso.

QWHUID] R 0L.QWHUID] Los métodos: PHWRGR . 3URSXHVWDV GH HVWLOR GH ORV IXHQWHV Utilice nombres significativos para los identificadores. y procure respetar la siguiente notación de mayúsculas y minúsculas: Œ Œ Œ Œ Las clases: &ODVH R 0L&ODVH Las interfaces: .

R PHWRGR/DUJR .

 Los métodos de acceso: JHW$WULEXWR .

 VHW$WULEXWR .

 Página 98 de 189 .

Guía de iniciación al lenguaje Java. Versión 2. además podrá recolectarles automáticamente con MDYDGRF.0. Escriba una única operación en cada línea. Si utiliza la notación estandarizada  . F. describiendo su funcionalidad. mediante la utilización de prefijos identificativos de usted o de su empresa. Octubre de 1999 Œ Œ Œ Las variables: DOWXUD R DOWXUD0HGLD Las constantes: &2167$7( R &2167$17(B/$5*$ Los paquetes: MDYDSDTXHWHVXESDTXHWH Cuide los nombres de sus clases y paquetes para que no coincidan con otros ya existentes. Inserte líneas en blanco en sus fuentes cuando mejoren la legibilidad. No deje de incluir comentarios en sus clases. Además se enuncian las siguientes recomendaciones: Œ Œ Œ Œ No utilice líneas de más de 80 caracteres. en su lugar divida la línea en varias.

Los atributos de las clases no deben de ser SXEOLF. Declare métodos de acceso a los atributos. Cree métodos de acceso a los atributos. 3URSXHVWDV GH GLVHxR GH ORV SURJUDPDV Para cada clase: Œ Œ Œ Œ Œ Œ Cree un constructor por defecto. JHW$WULEXWR .

y VHW$WULEXWR QXHYR9DORU.

Cree un método PDLQ .. Si no están implementados declárelos como private.

que valga para probar la clase. Sobre ILQDOL]H .

: Cree una bandera de finalización en cada clase. y en los ILQDOL]H .

lance una clase derivada de 5XQWLPH([FHSWLRQ No olvide llamar a VXSHUILQDOL]H . si la bandera no ha sido establecida..

Utilice interfaces antes que clases abstractas. Además se enuncian las siguientes recomendaciones: Œ Œ Œ Para más información véase >-RKQVRQ @ y >(FNHO @ ' *5$1'(6 352*5$0$6 Aunque con todo lo que se ha visto podríamos aventurarnos a desarrollar programas Java un tanto complejos (con varias clases. Cree paquetes para agrupar clases relacionadas. y resuelva un problema de una forma adecuada. La Ingeniería del Software hace posible que un programa sea mantenible y eficiente. WKUHDGV. no abuse de la herencia. Utilice composición cuando sea apropiado. Utilizar la herencia para simplificar las clases con características comunes. Desde este tutorial se apuesta por la Ingeniería del Software para el desarrollo de software de calidad.. paquetes. Página 99 de 189 . lo cierto es que el desarrollo de programas complejos es materia de la Ingeniería del Software.). en un tiempo mínimo y con unos costes mínimos..

se presenta como estándar de modelado. además de ser la metodología más extendida actualmente. Octubre de 1999 Desde aquí se recomienda el uso de una metodología orientada a objeto para el desarrollo del software. Versión 2. Página 100 de 189 . Todos los diagramas que se realicen siguiendo una metodología software deben de realizarse utilizando una notación unificada. El lenguaje de modelado UML >5DWLRQDO @. se ajusta bastante bien al desarrollo de Java. Por ejemplo OMT de >5DPEDXJK HW DO @.Guía de iniciación al lenguaje Java.0.

. %. Octubre de 1999 7(0$ .27(&$6 '( /$ $3. '( -$9$ Página 101 de 189 .0. Versión 2..Guía de iniciación al lenguaje Java.%/.

% 3$48(7(6 '( 87.9 %LEOLRWHFDV JUiILFDV de este tutorial. y para dibujar imágenes y gráficos. Versión 2. fechas. Octubre de 1999 . están bien documentadas (mediante páginas Web). Se estudia en el capítulo . y otras clases de utilidad..Guía de iniciación al lenguaje Java. MDYD[VZLQJ: Conjunto de componentes gráficos que funcionan igual en todas las plataformas que Java soporta. En este apartado explicaremos los paquetes básicos de la API de Java.'$'(6 Œ Œ Œ Œ Œ Œ MDYDODQJ: Fundamental para el lenguaje.. $SSOHWV de este tutorial.0.27(&$6 '( /$ $3. generación aleatoria de números. MDYDWH[W: Clases e interfaces para manejo de texto. aunque algunos de ellos tienen subpaquetes. MDYDXWLO: Contiene colecciones de datos y clases. MDYDLR: Para la entrada y salida a través de flujos de datos. &DGHQDV de este tutorial. %.. Estas clases se pueden incluir en los programas Java. MDYDEHDQV: Para el desarrollo de -DYD%HDQV.. Se estudia en el capítulo 9. MDYD[DFFHVLELOLW\: Da soporte a clases de accesibilidad para personas discapacitadas. MDYDPDWK: Clases para realizar aritmética con la precisión que se desee. facilidades horarias./. (QWUDGD6DOLGD de este tutorial. A este conjunto de paquetes (o bibliotecas) se le conoce como la API de Java (Application Programming Interface). el modelo de eventos.. MDYDDZW: Para crear interfaces con el usuario.9 %LEOLRWHFDV JUiILFDV de este tutorial. '( -$9$ $ .Ï1 Con cada una de las versiones que Sun lanza del JDK. Además. Œ Œ Página 102 de 189 . números y mensajes de una manera independiente a los lenguajes naturales. sin temor a fallos de portabilidad. y ficheros del sistema.. que se tratan más en detenimiento en el capítulo . se acompaña de una serie de bibliotecas con clases estándar que valen como referencia para todos los programadores en Java. Se estudia en el capítulo . Se estudia en el capítulo .%/.&2 Œ Œ Œ MDYDDSSOHW: Para crear applets y clases que las applets utilizan para comunicarse con su contexto.. & 3$48(7(6 3$5$ (/ '(6$552//2 *5È). y organizadas en paquetes y en un gran árbol de herencia.. MDYDVHFXULW\: Clases e interfaces para seguridad en Java: Encriptación RSA. Incluye clases como 6WULQJ o 6WULQJ%XIIHU.1752'8&&.

aunque esté codificados en distintos lenguajes. Versión 2. para conexión de programas Java con Bases de datos. Octubre de 1999 ' 3$48(7(6 3$5$ (/ '(6$552//2 (1 5(' Œ Œ Œ Œ Œ MDYDQHW: Clases para aplicaciones de red. para localizar objetos remotos.Guía de iniciación al lenguaje Java. similar al RMI pero en CORBA ( 3$5$ 0È6 . comunicarse con ellos e incluso enviar objetos como parámetros de un objeto a otro. RUJRPE&RV1DPLQJ : Da servicio al IDL de Java. Página 103 de 189 . Esta información ha sido extraída de la documentación de la API de Java correspondiente al JDK 1.com. para la conexión entre objetos distribuidos.Ï1 Para más información consulte con la documentación del JDK que vaya a utilizar o la dirección www. MDYDUPL: Paquete RMI.0.sun. MDYDVTO: Paquete que contiene el JDBC. RUJRPJ&25%$: Facilita la posibilidad de utilizar OMG CORBA.QWHUQHW de este tutorial.2 >6XQ @.1)250$&. Se estudia en el capítulo 9 -DYD H .

. Versión 2.0. Octubre de 1999 . &$'(1$6 $ .Ï1 D.1752'8&&.Guía de iniciación al lenguaje Java..

Si sólo existieran cadenas de sólo lectura (6WULQJ). El primer carácter de una cadena tiene el índice 0. . Los objetos 6WULQJ%XIIHU se pueden modificar. de forma que no son necesarios nuevos objetos para albergar los resultados intermedios. donde las cadenas son matrices de caracteres en las que se indica el final de la cadena con un carácter de valor ‘\0’. Los caracteres de las cadenas tienen un índice que indica su posición.QWURGXFFLyQ D ODV FODVHV 6WULQJ \ 6WULQJ%XIIHU En Java las cadenas se tratan de forma diferente a C/C++. durante una serie de manipulaciones sobre un objeto 6WULQJ habría que crear un nuevo objeto para cada uno de los resultados intermedios. En Java las cadenas son objetos de las clases predefinida 6WULQJ o 6WULQJ%XIIHU. el compilador de Java crea automáticamente un objeto 6WULQJ. pero resultar chocante para aquellos programadores que provengan de otros lenguajes. el tercero el 2 y así sucesivamente. El compilador es más eficiente y usa un objeto 6WULQJ%XIIHU para construir cadenas a partir de las expresiones. Esto puede sonar familiar a los programadores de C/C++. que están incluidas en el paquete MDYDODQJ  Siempre que aparecen conjuntos de caracteres entre comillas dobles. creando el 6WULQJ final sólo cuando es necesario. el segundo el 1. E.

Los siguientes métodos de acceso a las cadenas: Œ Œ Œ Œ LQW OHQJWK . 2SHUDFLRQHV EiVLFDV FRPXQHV D 6WULQJ \ 6WULQJ%XIIHU Existen una serie de métodos que son comunes a ambas clases.

. FKDU FKDU$W LQW L . Devuelve el número de caracteres de la cadena.

6WULQJ WR6WULQJ . Devuelve el carácter correspondiente de índice L.

 Devuelve una copia del objeto como una 6WULQJ 6WULQJ VXEVWULQJ LQW L LQW ILQ .

 Devuelve una instancia de la clase 6WULQJ que contenga una subcadena desde la posición LQL. hasta la ILQ (si no se indica hasta el final de la cadena). YRLG JHW&KDUV LQW LQL LQW ILQ FKDU>@ GHVWLQR LQW GHVW. del objeto cadena que invoque el método.QL.

Los siguientes métodos para crear cadenas derivadas: Y el método para transformar la cadena en un vector de caracteres: Œ Página 104 de 189 . Convierte la cadena en un vector de caracteres GHVWLQR.

Guía de iniciación al lenguaje Java. Versión 2.1* D. Octubre de 1999 % 0e72'26 '( /$ &/$6( 675.0.

&RQVWUXFWRUHV La clase 6WULQJ proporciona cadenas de sólo lectura y soporta operaciones con ellas. La clase 6WULQJ soporta multitud de constructores. También se pueden crear objetos 6WULQJ explícitamente con el mecanismo QHZ. Œ Œ Œ Œ Œ 6WULQJ . Se pueden crear cadenas implícitamente mediante una cadena entrecomillada o usando  ó  con dos objetos 6WULQJ.

El nuevo 6WULQJ toma el valor . Constructor por defecto. 6WULQJ 6WULQJ V .

copiando el que recibe por parámetro. Crea un nuevo 6WULQJ. 6WULQJ 6WULQJ%XIIHU V .

6WULQJ FKDU>@ Y . Crea un 6WULQJ con el valor que en ese momento tenga el 6WULQJ%XIIHU que recibe como parámetro.

 El nuevo 6WULQJ toma el valor de los caracteres que tiene el vector de caracteres recibido por parámetro. 6WULQJ E\WH>@ Y .

E. El nuevo 6WULQJ toma el valor de los caracteres que corresponden a los valores del vector de bytes en el sistema de caracteres de la ordenador en que se ejecute.

%~VTXHGD HQ FDGHQDV 6WULQJ Además presenta los siguientes métodos para buscar caracteres o subcadenas en la cadena. y devuelven el índice que han encontrado o el valor ± si la búsqueda no ha sido satisfactoria: Œ LQW LQGH[2I FKDU FK LQW VWDUW .

comenzando a buscar desde el carácter VWDUW (si no se especifica se busca desde el principio). LQW LQGH[2I 6WULQJ VWU .: Devuelve el índice correspondiente a la primera aparición del carácter FK en la cadena.

QGH[2I FKDU FK LQW VWDUW .: Devuelve el índice correspondiente al carácter en que empieza la primera aparición de la subcadena VWU LQW ODVW.

comenzando a buscar desde el carácter VWDUW (si no se especifica se busca desde el final).QGH[2I 6WULQJ VWU . LQW ODVW.: Devuelve el índice correspondiente a la última aparición del carácter FK en la cadena.

: Devuelve el índice correspondiente al carácter en que empieza la última aparición de la subcadena VWU Œ Œ Œ F.

puede que las comparaciones no sean las esperadas. habitual. &RPSDUDFLRQHV GH FDGHQDV 6WULQJ Java no trabaja con el código $6&. sobre todo. por el uso de dos bytes por carácter. sino con el código avanzado 8QLFRGH El código 8QLFRGH (código universal) se caracteriza. más importantes del mundo. y así se pueden representar los caracteres que componen las lenguas. vivas o muertas. Esto permite aumentar los caracteres hasta 65000. Página 105 de 189 ... Hay que tener en cuenta que si nos salimos del rango 0-255 que coincide con el código $6&.

Guía de iniciación al lenguaje Java. Octubre de 1999 Las funciones de comparación son las siguientes: Œ Œ Œ Œ Œ Œ ERROHDQ HTXDOV 2EMHFW R .0. Versión 2.

ERROHDQ HTXDOV.JQRUH&DVH 6WULQJ V . Devuelve WUXH si se le pasa una referencia a un objeto 6WULQJ con los mismos caracteres. o IDOVH si no.

 Compara cadenas ignorando las diferencias de ortografía mayúsculas/minúsculas. ERROHDQ UHJLRQ0DWFKHV ERROHDQ E LQW R 6WULQJ V  LQW L LQW Q .

carácter a carácter. Compara parte de dos cadenas. ERROHDQ VWDUWV:LWK 6WULQJ V LQW i .

Comprueba si la cadena tiene el prefijo V desde L ERROHDQ HQGV:LWK 6WULQJ V ..

LQW FRPSDUH7R 2EMHFW R . Comprueba si la cadena termina con el sufijo V.

igual o mayor que la otra. igual o mayor que cero cuando la cadena sobre la que se le invoca es menor. la comparación es léxica.JQRUD&DVH 6WULQJ V . Devuelve un entero que es menor. LQW FRPSDUH7R. Si el parámetro es un 6WULQJ.

 Compara lexicográficamente. ignorando las diferencias de ortografía mayúsculas/minúsculas. Œ G.

&DGHQDV 6WULQJ GHULYDGDV En Java se devuelven nuevas cadenas cada vez que se invoca a un método que crea una cadena diferente porque las cadenas 6WULQJ son de sólo lectura: Œ Œ Œ Œ Œ 6WULQJ UHSODFH FKDU ROG&KDU FKDU QHZ&KDU .

 Devuelve una nueva cadena con todos los caracteres ROG&KDU sustituidos por el carácter QHZ&KDU. 6WULQJ WR/RZHU&DVH .

siguiendo sus reglas. 6WULQJ WR8SHU&DVH /RFDOH O . Devuelve una nueva cadena con los caracteres en minúsculas. o si se especifica parámetro.

o si se especifica parámetro. Devuelve una nueva cadena con los caracteres en mayúsculas. VWDWLF 6WULQJ WULP . siguiendo sus reglas.

: Devuelve una nueva cadena del que se ha eliminado los espacios en blanco por el principio y por el final. VWDWLF 6WULQJ FRS\9DOXH2I FKDU>@ Y LQW LQL LQW ILQ .

VWDWLF 6WULQJ FRQFDW 6WULQJ V . entre los límites LQL y ILQ (si no se especifican copia todo el vector). Devuelve una cadena igual que la contenida en el vector Y.

Œ H. Concatena la cadena que recibe al final de ésta..

&RQYHUVLRQHV HQWUH FDGHQDV 6WULQJ \ WLSRV VLPSOHV -DYD Para convertir una variable de un tipo de datos simple (FKDU. ERROHDQ LQW ORQJ IORDW GRXEOH.

bastará con invocar al método YDOXH2I . en una cadena (6WULQJ).

del objeto 6WULQJ correspondiente: ΠVWDWLF 6WULQJ YDOXH2I WLSR .

Sin embargo para convertir el valor de una cadena en un tipo de datos simple deberemos utilizar los siguientes métodos: Página 106 de 189 . El parámetro WLSR soporta un carácter (FKDU) un vector de caracteres (FKDU>@) o un objeto (2EMHFW).

Octubre de 1999 ERROHDQ QHZ %RROHDQ 6WULQJ. Versión 2.Guía de iniciación al lenguaje Java.0.

ERROHDQ9DOXH .

QW 6WULQJ LQW EDVH.QWHJHU3DUVH. LQW .

ORQJ /RQJ3DUVH/RQJ 6WULQJ LQW EDVH.

IORDW QHZ )ORDW 6WULQJ.

IORDW9DOXH .

GRXEOH QHZ 'RXEOH 6WULQJ.

GRXEOH9DOXH .

7DEOD  &RQYHUVLRQHV GH FDGHQDV D WLSRV VLPSOHV 7LSR 'H 6WULQJ No hay ningún método que convierta los caracteres escapados Java ( \b. \uGGGG ) en variables carácter (FKDU.

Lo que se puede hacer es invocar YDOXH2I . o a la inversa.

Así mismo no hay formas de crear o decodificar cadenas de números en formatos octal () o hexadecimal([). I. con un carácter (FKDU) para obtener una cadena de la clase 6WULQJ que contenga ese carácter.

En cuanto a los vectores de caracteres existen: Œ Œ El constructor ya citado de 6WULQJ FKDU>@ Y . tanto de caracteres como de bytes. &RQYHUVLRQHV HQWUH FDGHQDV 6WULQJ \ YHFWRUHV También existen diversos constructores y métodos de la clase 6WULQJ para tratar con vectores.

por lo que las modificaciones posteriores del vector no afectarán a la cadena.. Hace copia de los datos. FKDU>@ WR&KDU$UUD\ .

En cuanto a los métodos para convertir vectores de E\WH (de 8 bits) en objetos 6WULQJ con caracteres 8QLFRGH de 16 bits existen: Œ Œ El constructor ya citado de 6WULQJ E\WH>@ Y . Convierte la cadena en un vector de caracteres.

por lo que las modificaciones posteriores del vector no afectarán a la cadena.. E\WH>@ JHW%\WHV 6WULQJ V . Hace copias de los datos.

 Convierte la cadena en un vector de E\WH. & 0e72'26 '( /$ &/$6( 675.1*%8))(5 D. atendiendo a la tabla de caracteres especificada en V. o a la de la máquina si se omite.

&RQVWUXFWRUHV Los constructores contenidos por la clase 6WULQJ%XIIHU son: ΠΠ6WULQJ%XIIHU LQW OLP .

si no se especifica otro valor). Construye una cadena sin caracteres y con una capacidad inicial de OLP caracteres (por defecto 16. 6WULQJ%XIIHU 6WULQJ V .

 Construye una cadena con el valor V. E.

0RGLILFDFLyQ GH OD FDGHQD Existen tres tipos de modificaciones que se pueden aplicar a la cadena. Hay métodos de inserción: Œ 6WULQJ%XIIHU LQVHUW LQW L 2EMHFW R .

 Desplaza los caracteres de la cadena e inserta la cadena correspondiente al segundo parámetro (de cualquier tipo). Página 107 de 189 .

Versión 2.Guía de iniciación al lenguaje Java.0. Octubre de 1999 Œ 6WULQJ%XIIHU DSSHQG 2EMHFW R .

 Inserta al final de la cadena. YRLG VHW&KDU$W LQW L FKDU WR . la cadena correspondiente al segundo parámetro (de cualquier tipo).

 Cambia el carácter de la posición L por WR. 6WULQJ%XIIHU UHSODFH LQW LQL LQW ILQ 6WULQJ V . se extiende rellenándose con caracteres nulos. Si la posición supera la longitud de la cadena.

 Reemplaza una subcadena de esta cadena (de LQL a ILQ) por la cadena recibida por parámetro. No se debe confundir con el método UHSODFH .

que incluye la clase 6WULQJ. 6WULQJ%XIIHU UHYHUVH .

6WULQJ%XIIHU GHOHWH LQW LQL LQW ILQ . Invierte la cadena (de izquierda a derecha)..

6WULQJ%XIIHU GHOHWH&KDU$W LQW L . Borra la subcadena entre el carácter LQL y el ILQ.

Hay métodos de substitución: Œ Œ Œ Œ Œ Y métodos de borrado: F. Borra el carácter en la posición L.

&DSDFLGDG GH OD FDGHQD El buffer de un objeto 6WULQJ%XIIHU tiene una FDSDFLGDG que es la longitud de la cadena que puede almacenar sin tener que asignar más espacio. El buffer crece automáticamente a medida que se añaden caracteres. pero resulta más eficiente especificar el tamaño del buffer de una sola vez: Œ Œ Œ LQW FDSDFLW\ .

YRLG HQVXUH&DSDFLW\ LQW L . Devuelve la capacidad actual del buffer.

YRLG VHW/HQJWK LQW L . Garantiza que la capacidad del buffer es al menos L..

 Establece la longitud de esta cadena a L. G.

debe invocarse el método WR6WULQJ . ([WUDFFLyQ GH GDWRV Para obtener un objeto 6WULQJ a partir de un objeto 6WULQJ%XIIHU.

Se debe tener en cuenta que no hay métodos 6WULQJ%XIIHU para eliminar una parte de un buffer. y construir un nuevo buffer con el contenido restante. común a ambas clases. Para esto se usa el método JHW&KDUV .. debe crearse un vector de caracteres a partir del buffer. Para resolver este problema.

común con la clase 6WULQJ.. ' (-(03/26 '( 862 '( &$'(1$6 D.

(MHPSOR GH &DGHQD )LMD GH OD FODVH 6WULQJ.

out. En el siguiente ejemplo se muestra la utilización de los principales métodos de la clase 6WULQJ: public static void main( String s[] ){ String cad = new String("Cadena Fija"). System. Página 108 de 189 .println("Su longitud es: "+cad.println("Ejemplo de String: ’"+cad+"’").length()).out. //Métodos comunes a StringBuffer System.

else System.out.out.out.out.println("Su tercer caracter es: "+cad. System.toCharArray().print("La subcadena '"+subcad+"'").substring(2.out.toLowerCase() ).out. // Comparaciones String cadcomp=new String("CADENA Fija").println(" ES igual 'Insensitive'"). // Derivación System.out.print("Su subcadena del 3 al 6 es:"). } Lo que muestra por pantalla: Ejemplo de String: 'Cadena Fija' Su longitud es: 11 Su tercer caracter es: e Su subcadena del 3 al 6 es: dena Creado un vector.6) ).print("La cadena '"+cadcomp+"'").compareTo(cadcomp) == 0 ) System. System. System. de elemento 3: "). char[] vectorcad = cad.out. System. System. Octubre de 1999 System.print("La cadena '"+cadcomp+"'"). System.out.out.equalsIgnoreCase(cadcomp) ) System.println( cad.print(" aparece en la posicion: ").println( cad.print("Cadena derivada en minusculas: ").out. System.println("Creado un vector.0.println(" NO = 'Insensitive'").out.out.Guía de iniciación al lenguaje Java. if ( cad. System. Versión 2. System. // Búsqueda en cadenas String subcad=new String("ena").out.charAt(3)).println(" NO es igual 'Sensitive'"). else System. de elemento 3: d La subcadena 'ena' aparece en la posicion: 3 La cadena 'CADENA Fija' NO es igual 'Sensitive' La cadena 'CADENA Fija' ES igual 'Insensitive' Cadena derivada en minusculas: cadena fija Página 109 de 189 .println( cad. System.out.print( vectorcad[2] ). if ( cad.indexOf(subcad) ).println(" ES igual 'Sensitive'").out.

Guía de iniciación al lenguaje Java. Octubre de 1999 E.0. Versión 2.

(MHPSOR GH &DGHQD 9DULDEOH GH OD FODVH 6WULQJ%XIIHU.

System.length().delete( 0.println("Tiene capacidad de: "+cad. cad. System. "da" ). } Lo que muestra por pantalla: Ejemplo de StringBuffer: 'Cadena Variable' Borrados 6 primeros caracteres: Variable Sutituidos ultimos caracteres: Variada Apendizada con 'Cadena': Variada Cadena Tiene capacidad de: 31 Capacidad sobre 32: 64 Página 110 de 189 .println("").out.capacity()). // Modificación de la cadena cad. En el siguiente ejemplo se muestra la utilización de los principales métodos de la clase 6WULQJ%XIIHU: public static void main( String s[] ){ StringBuffer cad = new StringBuffer("Cadena Variable").println("Borrados 6 primeros caracteres: "+cad). System.out.replace( cad. // Gestión de su capacidad System. 6 ).println("Capacidad sobre 32:"+cad.out.append(" Cadena").out.out. System. cad. cad.out. System.println("Apendizada con 'Cadena': "+cad).length()-3.println("Sutituidos ultimos caracteres: "+cad). cad.println("Ejemplo de StringBuffer: ’"+cad+"’"). System.ensureCapacity( 32 ).capacity()).out.

que constituyen un flujo de información del programa con el exterior.Ï1 Normalmente. Octubre de 1999 . (175$'$6$/. en muchas ocasiones interesa que el programa guarde los datos que se le han introducido. es decir. se les conoce como (QWUDGD6DOLGD ((6. de forma que si el programa termina los datos no se pierdan y puedan ser recuperados en una sesión posterior. Versión 2. que el usuario pueda pedirle que realice cosas y pueda suministrarle datos con los que se quiere que haga algo. cuando se codifica un programa. Una vez introducidos los datos y las órdenes...Guía de iniciación al lenguaje Java. se espera que el programa manipule de alguna forma esos datos para proporcionarnos una respuesta a lo solicitado.0.'$ $ . Además. A todas estas operaciones. La forma más normal de hacer esto es mediante la utilización de ficheros que se guardarán en un dispositivo de memoria no volátil (normalmente un disco). se hace con la intención de que ese programa pueda interactuar con los usuarios del mismo.1752'8&&.

ya que su resultado se mostrará en la ventana del terminal y no en la ventana de la DSSOHW. 6\VWHPRXW y 6\VWHPHUU D. Todas las operaciones de E/S en Java vienen proporcionadas por el paquete estándar de la API de Java denominado MDYDLR que incorpora interfaces. El acceso a la entrada y salida estándar es controlado por tres objetos que se crean automáticamente al iniciar la aplicación: 6\VWHPLQ. % (175$'$6$/. en la que se trabaja con ficheros de disco.'$ (67È1'$5 Aquí sólo trataremos la entrada/salida que se comunica con el usuario a través de la pantalla o de la ventana del terminal. clases y excepciones para acceder a todo tipo de ficheros.. Existen dos tipos de E/S. la (6 HVWiQGDU que se realiza con el terminal del usuario y la (6 D WUDYpV GH ILFKHUR. La ventana de la DSSOHW es una ventana gráfica y para poder realizar una entrada o salida a través de ella será necesario utilizar el AWT. En este tutorial sólo se van a dar algunas pinceladas de la potencia de este paquete. Si creamos una DSSOHW no se utilizarán normalmente estas funciones.

Los métodos que nos proporciona para controlar la entrada son: Œ UHDG . 6\VWHPLQ Este objeto implementa la entrada estándar (normalmente el teclado).

VNLS Q. Devuelve el carácter que se ha introducido por el teclado leyéndolo del buffer de entrada y lo elimina del buffer para que en la siguiente lectura sea leído el siguiente carácter. Si no se ha introducido ningún carácter por el teclado devuelve el valor -1.

 Ignora los Q caracteres siguientes de la entrada. Œ Página 111 de 189 .

Octubre de 1999 E.Guía de iniciación al lenguaje Java.0. Versión 2.

6\VWHPRXW Este objeto implementa la salida estándar. Los métodos que nos proporciona para controlar la salida son: Œ Œ SULQW D.

donde D puede ser cualquier tipo básico Java ya que Java hace su conversión automática a cadena. SULQWOQ D. Imprime D en la salida.

 Es idéntico a SULQW D.

salvo que con SULQWOQ .

F. se imprime un salto de línea al final de la impresión de D.

while(System.out.read()!=’\n’) contador++. G (MHPSOR A continuación vemos un ejemplo del uso de estas funciones que acepta texto hasta que se pulsa el retorno de carro e informa del número de caracteres introducidos. } } & (175$'$6$/.&+(52 D. // Retorno de carro "gratuito" System. class CuentaCaracteres { public static void main(String args[]) throws IOException { int contador=0. Las funciones que ofrece este objeto son idénticas a las proporcionadas por 6\VWHPRXW.println("Tecleados "+contador+" caracteres. 6\VWHPHUU Este objeto implementa la salida en caso de error. Normalmente esta salida es la pantalla o la ventana del terminal como con 6\VWHPRXW. System. import java.").println(). pero puede ser interesante redirigirlo.'$ 325 ).*. por ejemplo hacia un fichero.out.in. para diferenciar claramente ambos tipos de salidas.io.

Sin embargo los ficheros de acceso aleatorio permiten acceder a sus datos de una forma aleatoria. de una manera lineal (sin saltos). Una lectura secuencial implica tener que acceder a un elemento antes de acceder al siguiente. 7LSRV GH ILFKHURV En Java es posible utilizar dos tipos de ficheros (de texto o binarios) y dos tipos de acceso a los ficheros (secuencial o aleatorio). esto es indicando una determinada posición desde la que leer/escribir. mientras que los binarios pueden almacenar cualquier tipo de datos (LQW. ERROHDQ). Los ficheros de texto están compuestos de caracteres legibles. es decir. IORDW. Página 112 de 189 .

Octubre de 1999 E.0. Versión 2.Guía de iniciación al lenguaje Java.

En este tutorial sólo vamos a trata las tres principales: Œ Œ Œ )LOH2XWSXW6WUHDP: Fichero de salida de texto. 5DQGRP$FFHVV)LOH: Fichero de entrada o salida binario con acceso aleatorio. saltar hacia delante y hacia atrás para leer la información que necesitemos en cada momento. )LOH. Estos ficheros permiten multitud de operaciones. F. Representa ficheros de texto para escritura a los que se accede de forma secuencial. &ODVHV D HVWXGLDU En el paquete MDYDLR existen varias clases de las cuales podemos crear instancias de clases para tratar todo tipo de ficheros.QSXW6WUHDP: Fichero de entrada de texto. e incluso leer o escribir partes del fichero sin necesidad de cerrarlo y volverlo a abrir en un modo distinto. Representa ficheros de texto de sólo lectura a los que se accede de forma secuencial. Es la base para crear los objetos de tipo fichero de acceso aleatorio.

excepto para los objetos de la clase 5DQGRP$FFHVV)LOH (acceso aleatorio). Se abre el fichero. *HQHUDOLGDGHV Para tratar con un fichero siempre hay que actuar de la misma manera: 1. para los que se ha de instanciar de la siguiente forma: RandomAccessFile obj = new RandomAccessFile( ruta. y el tipo de acceso que vamos a utilizar: TipoDeFichero obj = new TipoDeFichero( ruta ). Los métodos de estas clases pueden lanzar excepciones de esta clase (o sus hijas) en el transcurso de su ejecución. Gestión de excepciones (opcional. Donde PRGR es una cadena de texto que indica el modo en que se desea abrir el fichero. pero recomendada) Se puede observar que todos los métodos que utilicen clases de este paquete deben tener en su definición una cláusula WKURZV . Para ello hay que crear un objeto de la clase correspondiente al tipo de fichero que vamos a manejar. 3. Para cerrar un fichero lo que hay que hacer es destruir el objeto. Se cierra el fichero y se destruye el objeto. Este formato es válido. 2. "r" para sólo lectura o "rw" para lectura y escritura. Donde UXWD es la ruta de disco en que se encuentra el fichero o un descriptor de fichero válido. y dichas excepciones deben de ser capturadas y debidamente gestionadas para evitar problemas. dejando que sea el recolector de basura de Java el que lo destruya cuando no lo necesite (no se recomienda) o destruyendo el objeto explícitamente mediante el uso del procedimiento cORVH . Se utiliza el fichero. modo ). 4. Esto se puede realizar de dos formas. Para ello cada clase presenta diferentes métodos de acceso para escribir o leer en el fichero.2([FHSWLRQ.

del objeto: obj.close() Página 113 de 189 .

0.Guía de iniciación al lenguaje Java. Octubre de 1999 G. Versión 2.

Presenta el método ZULWH . /D FODVH )LOH2XWSXW6WUHDP Mediante los objetos de esta clase escribimos en ficheros de texto de forma secuencial.

para la escritura en el fichero. Presenta varios formatos: ΠΠΠLQW ZULWH LQW F .

 Escribe el carácter en el fichero. LQW ZULWH E\WH D>@ .

LQW ZULWH E\WH D>@ LQW RII LQW OHQ . Escribe el contenido del vector en el fichero.

} } H. El siguiente ejemplo crea el fichero de texto "FDUWDW[W" a partir de un texto que se le introduce por teclado: import java.read() ) != -1 ) f. f.*.in.close().io.txt").write( (char)c ). FileOutputStream f=new FileOutputStream("/carta. Escribe OHQ caracteres del vector D en el fichero. while( ( c=System. class CreaCarta { public static void main(String args[]) throws IOException{ int c. comenzando desde la posición RII.

QSXW6WUHDP Mediante los objetos de esta clase leemos de ficheros de texto de forma secuencial. /D FODVH )LOH. Presenta el método UHDG .

Œ Œ LQW UHDG . para la lectura del fichero. Este método se puede invocar de varias formas.

LQW UHDG E\WH D>@ . Devuelve el siguiente carácter del fichero.

Devuelve la longitud del vector que se ha llenado si se realizó con éxito o –1 si no había suficientes caracteres en el fichero para llenar el vector. Llena el vector D con los caracteres leídos del fichero. LQW UHDG E\WH D>@ LQW RII LQW OHQ .

read() ) != -1 ) System.out. insertándolos en el vector D. while( ( c=f.*.txt").io. class MuestraCarta { public static void main(String args[]) throws IOException { int c. Œ Todos ellos devuelven -1 si se ha llegado al final del fichero (momento de cerrarle). FileInputStream f=new FileInputStream("/carta. Página 114 de 189 .print( (char)c ). Lee OHQ caracteres del fichero. El siguiente ejemplo muestra el fichero de texto "FDUWDW[W" en pantalla: import java.

} } I.0. Octubre de 1999 f. Versión 2.Guía de iniciación al lenguaje Java.close().

tanto para lectura como para escritura. Œ Œ Œ Œ Œ Œ ORQJ JHW)LOH3RLQWHU . Métodos de desplazamiento Cuenta con una serie de funciones para realizar el desplazamiento del puntero del fichero. y con el que se puede trabajar para posicionarse en el fichero. Hay que tener en cuenta que cualquier lectura o escritura de datos se realizará a partir de la posición actual del puntero del fichero. En estos ficheros hay un índice que nos dice en qué posición del fichero nos encontramos. /D FODVH 5DQGRP$FFHVV)LOH Mediante los objetos de esta clase utilizamos ficheros binarios mediante un acceso aleatorio.

Devuelve la posición actual del puntero del fichero. YRLG VHHN ORQJ O .

LQW VNLS%\WHV LQW Q . Coloca el puntero del fichero en la posición indicada por O. Un fichero siempre empieza en la posición 0.

ORQJ OHQJWK . Intenta saltar Q bytes desde la posición actual.

YRLG VHW/HQJWK ORQJ O. Devuelve la longitud del fichero.

)LOH'HVFULSWRU JHW)' . Establece a O el tamaño de este fichero.

 Devuelve el descriptor de este fichero. Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ YRLG ZULWH E\WH E>@ LQW LQL LQW OHQ . Métodos de escritura La escritura del fichero se realiza con una función que depende el tipo de datos que se desee escribir.

YRLG ZULWH LQW L . Escribe OHQ caracteres del vector E.

 Escribe la parte baja de L (un byte) en el flujo. YRLG ZULWH%RROHDQ ERROHDQ E .

YRLG ZULWH%\WH LQW L . Escribe el boolean E como un byte.

 Escribe L como un byte. YRLG ZULWH%\WHV 6WULQJ V .

no caracteres. YRLG ZULWH&KDU LQW L . Escribe la cadena s tratada como bytes.

YRLG ZULWH&KDUV 6WULQJ V . Escribe L como 1 byte.

YRLG ZULWH'RXEOH GRXEOH G . Escribe la cadena V.

. Convierte G a ORQJ y le escribe como 8 bytes. YRLG ZULWH)ORDW IORDW I .

 Convierte I a entero y le escribe como 4 bytes.QW LQW L . YRLG ZULWH.

Escribe L como 4 bytes.. YRLG ZULWH/RQJ ORQJ Y .

YRLG ZULWH6KRUW LQW L . Escribe Y como 8 bytes.

 Escribe L como 2 bytes. YRLG ZULWH87) 6WULQJ V .

 Escribe la cadena V utilizando la codificación UTF-8. Los métodos que escriben números de más de un byte escriben el primero su parte alta. Página 115 de 189 .

Octubre de 1999 Métodos de lectura La lectura del fichero se realiza con una función que depende del tipo de datos que queremos leer. Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ ERROHDQ UHDG%RROHDQ .Guía de iniciación al lenguaje Java. Versión 2.0.

 Lee un byte y devuelve IDOVH si vale 0 o WUXH sino. E\WH UHDG%\WH .

 Lee y devuelve un byte. FKDU UHDG&KDU .

GRXEOH UHDG'RXEOH . Lee y devuelve un caracter.

 Lee 8 bytes. IORDW UHDG)ORDW . y devuelve un GRXEOH.

YRLG UHDG)XOO\ E\WH E>@ . y devuelve un IORDW. Lee 4 bytes.

 Lee bytes del fichero y los almacena en un vector E. YRLG UHDG)XOO\ E\WH E>@ LQW LQL LQW OHQ .

LQW UHDG.QW . Lee OHQ bytes del fichero y los almacena en un vector E.

ORQJ UHDG/RQJ . Lee 4 bytes. y devuelve un LQW.

y devuelve un ORQJ. VKRUW UHDG6KRUW . Lee 8 bytes.

 Lee 2 bytes. y devuelve un VKRUW. LQW UHDG8QVLJQHG%\WH .

 Lee 1 byte. y devuelve un valor de 0 a 255. LQW UHDG8QVLJQHG6KRUW .

6WULQJ UHDG87) . y devuelve un valor de 0 a 65535. Lee 2 bytes.

 Lee una cadena codificada con el formato UTF-8. LQW VNLS%\WHV LQW Q.

// No se puede seguir escribiendo } f. Salta Q bytes del fichero. El siguiente ejemplo crear un fichero binario que contiene los 100 primeros números (en orden): // Crea un fichero binario con los 100 primeros numeros static void creaFichBin( String ruta ) throws IOException { RandomAccessFile f=new RandomAccessFile(ruta. // E/S for ( int i=1. mediante acceso aleatorio. Si no es posible la lectura devuelven ±."rw").close().writeByte( i ). i++ ) { try{ f. i <= 100 . } Página 116 de 189 . Ejemplo Vamos a crear un pequeño programa que cree y acceda a un fichero binario. } catch( IOException e){ // Gestion de excepcion de ejemplo break.

System.readByte() ).println( " ocupa " + f. long cual) throws IOException{ RandomAccessFile f=new RandomAccessFile(ruta. // Salto 9 => Elemento 10 mas alla System.println( f. System. Versión 2. imprimiendo la longitud del fichero.out.Guía de iniciación al lenguaje Java.out."r"). } Si incluimos ambos métodos en una clase. // E/ System.out.length() + " bytes.out. f.close().print( "El fichero " + ruta ).readByte() ). esta el ").print(" En la posicion " + f.seek( cual-1 ).skipBytes( 9 ).out. y les llamamos con el siguiente programa principal (PDLQ ." ).out.0. el elemento FXDO y su 10 veces siguiente elemento: static void imprimeEltoN(String ruta. // Me posiciono (-1 porque empieza en 0) System. System.getFilePointer() ). f. f.println(" esta el numero " + f. Octubre de 1999 El siguiente método accede al elemento FXDO de un fichero binario.print(" 10 elementos más allá.

// Accedo al elemento 14.): public static void main(String args[]) throws IOException { String ruta="numeros.dat". 14 ). esta el 24 Página 117 de 189 . // Se crea imprimeEltoN( ruta. En la posicion 13 esta el numero 14 10 elementos más allá. } Obtendremos la siguiente salida: El fichero numeros. // Fichero creaFichBin( ruta ).dat ocupa 100 bytes.

27(&$6 *5È).9 %.Guía de iniciación al lenguaje Java.0./. Versión 2.&$6 Página 118 de 189 . Octubre de 1999 7(0$ .

y si esto sucede. Œ AWT presenta componentes pesados. Está disponible desde la versión 1. Octubre de 1999 . Está disponible desde la versión 1.1 del JDK como MDYDDZW.0. que en Swing se amplía con el paquete MDYD[VZLQJHYHQW. Swing presenta componentes ligeros.&26 '( /$6 -)& $ . Ej: se ha pulsado una tecla (. La clase base para todos estos eventos que se pueden lanzar es la clase $:7(YHQW (perteneciente al paquete MDYDDZW). mientras que Swing se estudia en el apartado .2 del JDK como MDYD[VZLQJ aunque antes se podían encontrar versiones previas como FRPVXQMDYD o como MDYDDZWVZLQJ Œ AWT se estudia con más detenimiento en el apartado . Para cada objeto que represente una interfaz gráfica. Así como Sun presenta estas JFC. % 02'(/2 '( (9(1726 Tanto AWT como Swing tienen en común un sistema para gestionar los eventos que se producen al interactuar con el usuario de la interfaz gráfica. Existen dos tipos básicos de eventos: Œ Œ Físicos: Corresponden a un evento hardware claramente identificable. él es avisado. Por ejemplo se puede crear un objeto oyente que esté a la espera de que el usuario pulse sobre un botón de la interfaz.Ï1 Las JFC (Java Foundation Classes) son parte de la API de Java compuesto por clases que sirven para crear interfaces gráficas visuales para las aplicaciones y DSSOHWV de Java. que sucedidos en un determinado orden tienen un significado más abstracto: El usuario ha elegido un elemento de una lista desplegable (. Página 119 de 189 . su PRGHOR GH HYHQWRV.96ZLQJ de este tutorial. El modelo de eventos de AWT depende del paquete MDYDDZWHYHQW. ejecutando determinada acción.Guía de iniciación al lenguaje Java.9$:7 de este tutorial.H\6WURNH(YHQW). que pueden tomar diferente aspecto y comportamiento pues lo toman de una biblioteca de clases.1752'8&&. Microsoft ha desarrollado otro paquete propio con el nombre de AFD (Application Foundation Classes). se pueden definir objetos "oyentes" (/LVWHQHU).WHP(YHQW). Semánticos: Se componen de un conjunto de eventos físicos.9 /26 3$48(7(6 *5È). que en cada plataforma sólo pueden tener una representación determinada. El funcionamiento del modelo de eventos se basa en la gestión de excepciones. que esperen a que suceda un determinado evento sobre la interfaz. Las JFC contienen dos paquetes gráficos: AWT y Swing. Versión 2.

ordenados por orden de antigüedad. Octubre de 1999 & 68%3$48(7(6 '( $:7 A continuación se enumeran los paquetes que componen las JFC. así como su funcionalidad. Esto es importante. Versión 2. ya que normalmente los navegadores no soportan la última versión de la API de Java en su propia máquina virtual.Guía de iniciación al lenguaje Java. Si queremos que nuestra DSSOHW se vea igual en varios navegadores. comprobando la versión de Java que soportan los navegadores que nos interesen. D.0. porque debe de tenerse en cuenta si se va a utilizar para crear DSSOHWV. deberemos de tener en cuenta qué paquetes podemos utilizar y cuáles no.

así como la clase base para los eventos en componentes: $:7(YHQW. Œ E. 'HVGH OD YHUVLyQ  Œ MDYDDZW: Contiene todas las clases básicas de AWT para crear interfaces e imprimir gráficos e imágenes. MDYDDZWLPDJH: Para crear y modificar imágenes. Permite renderizar una imagen mientras está siendo generada. Utiliza productores de imágenes. filtros y "consumidores de imágenes".

ΠF. MDYDDZWHYHQW: Modelo de eventos de AWT. oyentes y adaptadores a oyentes. Permite definir clases "transferibles" entre aplicaciones. 'HVGH OD YHUVLyQ  ΠMDYDDZWGDWDWUDQVIHU: Transferencia de datos entre aplicaciones. y da soporte al mecanismo del portapapeles (copiar y pegar). Contiene eventos.

MDYDDZWLPDJHUHQGHUDEOH: Para producir imágenes que sean LQGHSHQGLHQWHV GH UHGHULQJ (animación). Incorpora capacidad para gestionar diversos tipos de documentos. Contiene la implementación de una paleta de colores basada en la especificada por el ICC (Consorcio Internacional de Color). Soporta fuentes del tipo True Type. Type 1. Chinos o Coreanos.. MDYDDZWSULQW: Para imprimir documentos. formatos de página e interactuar con el usuario para controlar la impresión de trabajos. Type 1 Multiple Master. para crear objetos en 2 dimensiones. utilizando geometría plana (elipses. Página 120 de 189 ..). MDYDDZWLP: Para utilizar símbolos Japoneses. MDYDDZWIRQW: Todo lo referente a las fuentes de texto. y OpenType. curvas. áreas. MDYDDZWJHRP Aporta clases de Java 2D. 'HVGH OD YHUVLyQ  Œ Œ Œ Œ Œ Œ Œ MDYDDZWFRORU: Utilización de colores. MDYDDZWGQG: Operaciones de arrastrar y soltar.

MDYD[VZLQJSODI: Permite a Swing utilizar múltiples representaciones. MDYD[VZLQJSODIPXOWL: Permite a los usuarios combinar aspectos de interfaz. MDYD[VZLQJILOHFKRRVHU: Para utilizar el componente -)LOH&KRRVHU.Guía de iniciación al lenguaje Java. MDYD[VZLQJWH[W: Para manejar componentes de texto (modificables o no).. basada en la versión 3.0. MDYD[VZLQJWUHH: Para personalizar la forma en que son utilizados los árboles generados por la clase MDYDDZWVZLQJ-7UHH. entre auxiliares y los que existen por defecto. MDYD[VZLQJERUGHU: Para dibujar bordes personalizados en los componentes Swing. En este paquete se encuentran gestores de impresión. Soporta sintaxis resaltada. MDYD[VZLQJSODIPHWDO: Objetos que utilizan interfaces de aspecto "Metal". Œ Œ Œ Œ Œ Œ Œ Œ Œ Página 121 de 189 . Se utiliza por aquellos desarrolladores que no pueden crear un nuevo aspecto de interfaz.. Octubre de 1999 ' 68%3$48(7(6 '( 6:. MDYD[VZLQJXQGR: Permite realizar operaciones de GHVKDFHUUHKDFHU en las aplicaciones que cree el usuario. Extiende los que se encuentran en el paquete AWT MDYDDZWHYHQW.2 de la especificación HTML.1* A continuación se enumeran los paquetes que componen Swing. Versión 2. MDYD[VZLQJWH[WKWPO: Contiene la clase +70/(GLWRU. MDYD[VZLQJSODIEDVLF: Objetos que utilizan interfaces de aspecto "Basic". oyentes y adaptadores. MDYD[VZLQJHYHQW: Eventos lanzados por componentes Swing. Este aspecto es el que presentan por defecto los componentes Swing. edición. MDYD[VZLQJFRORUFKRRVHU: Para utilizar el componente -&RORU&KRRVHU. MDYD[VZLQJWH[WUWI: Contiene la clase 57)(GLWRU.LW. Se puede crear un aspecto personalizado de interfaz utilizando este paquete. estilos. así como oyentes para dichos eventos. y clases para crear editores de texto HTML MDYD[VZLQJWH[WKWPOSDUVHU: Contiene analizadores de texto HTML. basado en los que Swing ya incorpora (como Basic o Metal). eventos.LW para crear editores de documentos en formato RTF (Rich-Text-Format). así como su funcionalidad: Œ Œ Œ Œ Œ Œ MDYD[VZLQJ: Tiene los componentes básicos para crear componentes ligeros Swing.

Versión 2.9 $:7 $EVWUDFW :LQGRZLQJ 7RRONLW.0. Octubre de 1999 .Guía de iniciación al lenguaje Java.

La siguiente figura muestra la jerarquía de clases para las principales clases de AWT: . Su propósito principal es representar algo que tiene una posición y un tamaño. % &20321(17 Esta clase representa a cualquier objeto que puede ser parte de una interfaz gráfica de usuario.PDJHQ  -HUDUTXtD GH ODV FODVHV GH $:7 En este apartado vamos a estudiar algunas de las clases más importantes del AWT. que puede ser dibujado en la pantalla y que pueda recibir eventos de entrada (que responda a las interacciones con el usuario). así como su funcionalidad. $ . A continuación se explican algunos de ellos.1752'8&&.Ï1 AWT es un conjunto de herramientas GUI (Interfaz Gráfica con el Usuario) diseñadas para trabajar con múltiples plataformas. Página 122 de 189 . organizados para cubrir varios propósitos. (MHPSOR GH FUHDFLyQ GH XQD DSSOHW" se muestra un breve ejemplo de cómo utilizar las clases del AWT para crear una DSSOHW y una aplicación de Java. Este paquete viene incluido en la API de Java como MDYDDZW ya desde su primera versión. En el apartado "9. lo que les hace especialmente eficientes para la creación de DSSOHWV Java). con lo que las interfaces generadas con esta biblioteca funcionan en todos los entornos Java disponibles (incluyendo navegadores. Es la clase padre de muchas de las clases del AWT. La clase &RPSRQHQW presenta diversos métodos.

Versión 2. Octubre de 1999 D.Guía de iniciación al lenguaje Java.0.

7DPDxR \ SRVLFLyQ GHO FRPSRQHQWH ΠΠΠΠΠΠΠΠ'LPHQVLRQ JHW6L]H .

 Devuelve la anchura y altura del componente como un objeto de la clase 'LPHQVLRQ. YRLG VHW6L]H LQW DQFKR LQW ODUJR. que tiene como campos: ZLGWK (anchura) y KHLJWK (altura).

'LPHQVLRQ JHW3UHIHUUHG6L]H . Establece la anchura y altura del componente.

 Devuelve el tamaño que este componente debería tener. YRLG VHW3UHIHUUHG6L]H .

 Establece el tamaño que este componente debería tener. 'LPHQVLRQ JHW0LQLPXP6L]H .

 Devuelve el tamaño mínimo que este componente debería tener. YRLG VHW0LQLPXP6L]H LQW DQFKR LQW ODUJR.

5HFWDQJOH JHW%RXQGV . Establece el tamaño mínimo que este componente debería tener.

YRLG VHW%RXQGV LQW [ LQW \ LQW DQFKR LQW ODUJR. que tiene como campos: [ \ ZLGWK \ KHLJWK. Devuelve las coordenadas de este componente como un objeto de la clase 5HFWDQJOH.

E. Establece las coordenadas de este componente.

$FFLRQHV VREUH HO FRPSRQHQWH ΠΠΠΠΠΠΠERROHDQ JHW(QDEOHG .

YRLG VHW(QDEOHG ERROHDQ. Comprueba si el componente está o no activo.

ERROHDQ JHW9LVLEOH . Establece el componente a activo o inactivo.

YRLG VHW9LVLEOH ERROHDQ. Comprueba si el componente está o no visible.

YRLG SDLQW *UDSKLFV J. Establece si el componente está visible o invisible.

 Indica al AWT que ha de dibujar el componente J. YRLG UHSDLQW .

YRLG XSGDWH *UDSKLFV J. Indica al AWT que ha de volver a dibujar el componente.

 Es llamado por AWT cuando se invoca el método UHSDLQW .

Por defecto llama a SDLQW ..

. F.

1). Hay tres tipos de métodos: Œ Œ Œ YRLG DGGB7LSRB/LVWHQHU B7LSRB/LVWHQHU O. para la gestión de eventos mediante el nuevo modelo de eventos de AWT (desde la versión 1. (YHQWRV GH LQWHUDFFLyQ FRQ HO XVXDULR A su vez hay tres tipos de métodos.

 Añade un oyente a la espera de algún tipo de eventos sobre este componente. YRLG UHPRYHB7LSRB/LVWHQHU B7LSRB/LVWHQHU O.

 Elimina algún oyente que estaba a la espera de algún tipo de eventos sobre este componente. YRLG SURFHVVB7LSRB(YHQW B7LSRB(YHQW H.

. Página 123 de 189 .H\. 0RXVH. Procesa eventos del tipo _7LSRB(YHQW enviándolos a cualquier objeto _7LSRB/LVWHQHU que estuviera escuchando.QSXW0HWKRG. . 0RXVH0RWLRQ. En estos métodos B7LSRB puede ser cualquiera de los siguientes: &RPSRQHQW )RFXV.

Octubre de 1999 & &217$. Versión 2.0. Algunos de los métodos de la clase &RQWDLQHU son: Œ Œ Œ Œ &RPSRQHQW DGG &RPSRQHQW F.1(5 La clase &RQWDLQHU sabe cómo mostrar componentes embebidos (que a su vez pueden ser instancias de la clase &RQWDLQHU).Guía de iniciación al lenguaje Java.

YRLG SULQW *UDSKLFV J. Añade un componente al contenedor.

YRLG SULQW&RPSRQHQWV *UDSKLFV J. Imprime el contenedor.

/D\RXW0DQDJHU JHW/D\RXW . Imprime cada uno de los componentes de este contenedor.

que es el responsable de colocar los componentes dentro del contenedor. Devuelve el gestor de impresión (/D\RXW0DQDJHU) asociado a este contenedor. YRLG VHW/D\RXW /D\RXW0DQDJHU .

Œ Estos objetos &RQWDLQHU tienen un /D\RXW0DQDJHU asociado que define la manera en que van a posicionarse los objetos componentes en su interior. ' *(6725(6 '( . De estas interfaces se proporcionan cinco implementaciones en AWT. Cada una de ellas reparte los objetos de una forma particular: Œ Œ Œ Œ Œ %RUGHU/D\RXW: En cinco lugares: Norte. )ORZ/D\RXW: De izquierda a derecha horizontalmente en cada línea. &DUG/D\RXW: Permite gestionar varios componentes de los que sólo uno se visualiza a la vez.Ï1 /D\RXW0DQDJHU y /D\RXW0DQDJHU son dos interfaces encargadas de la representación y posicionamiento en pantalla de componentes AWT. A continuación explicamos algunas de ellas. Este. Cuando sobrepasan una línea se comienza a la izquierda de la siguiente. permaneciendo los demás invisibles debajo. Sur. pero las casillas no tienen que tener el mismo tamaño. Dentro de esta biblioteca podemos encontrar multitud de clases prefabricadas para facilitar el diseño gráfico. *ULG%DJ/D\RXW: En una tabla.035(6. *ULG/D\RXW: En una tabla en la que todas las casillas tienen el mismo tamaño. Establece un gestor de impresión para este componente. ( 275$6 &/$6(6 Por supuesto AWT no se limita a estas clases. D. Oeste y Centro (1RUWK 6RXWK (DVW :HVW y &HQWHU).

Página 124 de 189 . La clase $SSOHW que sirve para crear DSSOHWV Java. &ODVHV FRQWHQHGRUDV KLMDV GH &RQWDLQHU Œ 3DQHO: Permite hacer una presentación más avanzada que &RQWDLQHU mediante la combinación con subpaneles o subclases para crear contenedores personalizados. hereda de esta clase 3DQHO.

Puede tener asociado un objeto 0HQXEDU (una barra de herramientas o barra de menú personalizada). E. )LOHGLDORJ: Un diálogo que usa el selector de archivos nativo del sistema operativo.0. Versión 2.Guía de iniciación al lenguaje Java. Tiene la capacidad de ser PRGDO con lo que sólo este contenedor recibiría entradas del usuario. Octubre de 1999 Œ Œ Œ Œ Œ 6FUROO3DQH: Una barra de desplazamiento. )UDPH: Una ventana que no tiene borde. 'LDORJ: Una ventana usada para crear diálogos. :LQGRZ: Una ventana sin borde. horizontal o vertical.

&ODVHV FRPSRQHQWHV KLMDV GLUHFWDV GH &RPSRQHQW.

7H[W&RPSRQHQW: Cualquier componente que permita editar cadenas de texto. Œ Œ Œ Œ Œ Œ Œ Œ %XWWRQ: Un botón gráfico para el que se puede definir una acción que sucederá cuando se presione el botón. /LVW: Una lista desplegable de cadenas.Tiene dos clases hijas: Œ Œ 7H[W)LHOG: Componente de texto consistente en una línea que puede ser usada para construir formularios. &KHFNER[: Soporta dos estados: RQ y RII. que se explican a continuación. D. &DQYDV: Permite pintar o capturar eventos del usuario. &KRLFH: Menú desplegable de opciones. ) (9(1726 '( $:7 AWT tiene sus propios eventos. Se puede usar para crear gráficos o como clase base para crear una jerarquía de componentes personalizados. Se pueden asociar acciones que se ejecuten (WULJJHUV) cuando el estado cambie. /DEHO: Cadena de etiqueta en una localización dada. 6FUROOEDU: Desplegable de objetos &DQYDV. 7H[W$UHD: Componente para edición de texto de tamaño variable.

&RQWDLQHU(YHQW: Se envía cuando se añaden o eliminan componentes a un contenedor.H\(YHQW (pulsación de una tecla) y 0RXVH(YHQW (acción sobre el ratón). como los controles de minimizar o cerrar. Tiene como eventos hijos . )RFXV(YHQW: Avisa al programa de que el componente ha ganado o perdido la DWHQFLyQ (enfoque) del usuario. que indica algún cambio en un objeto &RPSRQHQW: Œ Œ . (YHQWRV ItVLFRV Son todos hijos del evento &RPSRQHQW(YHQW. Esto se deduce de la actividad del usuario (ratón y teclado). Œ Œ Página 125 de 189 .QSXW(YHQW: Se ha producido una entrada del usuario. :LQGRZ(YHQW: Avisa al programa de que el usuario ha utilizado uno de los controles de ventana a nivel del sistema operativo.

Un componente debe sobreescribir el método SDLQW . Versión 2.Guía de iniciación al lenguaje Java. Octubre de 1999 Œ 3DLQW(YHQW: Evento especial que señala que el sistema operativo quiere dibujar de nuevo una parte de la interfaz.0.

o el método XSGDWH .

E. para gestionar este evento.

QYRFDWLRQ(YHQW: Este evento ejecuta el método UXQ . ..WHP(YHQW: Avisa al programa cuando el usuario interacciona con una elección. (YHQWRV VHPiQWLFRV Son todos hijos del evento $:7(YHQW.QSXW0HWKRG(YHQW: Avisa que un texto que está siendo creado utilizando un método de entrada está cambiando (se ha escrito algo más. 7H[W(YHQW: Avisa cuando un usuario cambia texto en un componente 7H[W&RPSRQHQW 7H[W$UHD o 7H[W)LHOG.. . que es el evento base de la jerarquía de eventos: Œ Œ Œ Œ Œ Œ $FWLRQ(YHQW: Avisa al programa de acciones específicas de componentes como las pulsaciones de botones. una lista o una casilla de verificación. $GMXVWPHQWH(YHQW: Comunica que una barra de desplazamiento ha sido ajustada.). .

en una clase 5XQQDEOH cuando es tratado por el WKUHDG del despachador (GLVSDWFKHU) de AWT. Página 126 de 189 .

En la versión 1.2 de la API de Java se incluyen tres bibliotecas de aspecto y comportamiento para Swing: Œ Œ Œ PHWDOMDU: Aspecto y comportamiento independiente de la plataforma. (MHPSOR GH FUHDFLyQ GH XQD DSSOHW" se muestra un breve ejemplo de cómo utilizar las clases de Swing para crear una aplicación utilizando Swing. Por ejemplo: -%XWWRQ. ZLQGRZVMDU: Muy similar a las interfaces Microsoft Windows 95. En el apartado "9. que corresponde a la distribuida en la versión 1.2 de Java.Guía de iniciación al lenguaje Java.9 6:. % 18(9$6 &$5$&7(5Ë67.&$6 La arquitectura Swing presenta una serie de ventajas respecto a su antecedente AWT: Œ Amplia variedad de componentes: En general las clases que comiencen por "J" son componentes que se pueden añadir a la aplicación.PDJHQ  'LIHUHQWHV DVSHFWRV GH XQD LQWHUID] 6ZLQJ Es la nueva clase denominada 8L0DQDJHU la que se encarga del aspecto y comportamiento de una aplicación Swing en un entorno de ejecución. Cada uno de los componentes de este paquete puede presentar diversos aspectos y comportamientos en función de una biblioteca de clases. Está compuesto por un amplio conjunto de componentes de interfaces de usuario que funcionen en el mayor número posible de plataformas. Página 127 de 189 .0.0 de Swing. PRWLIMDU: Basado en la interfaz Sun Motif.2) que muestra las diferentes interfaces para una misma aplicación según se utilice una u otra biblioteca: .1752'8&&. Octubre de 1999 .Ï1 El paquete Swing es el nuevo paquete gráfico que ha aparecido en la versión 1. Versión 2.1* $ . La siguiente imagen muestra una aplicación de ejemplo (adjunta al JDK 1.

2 AWT" de este tutorial tienen una nueva versión en Swing con el prefijo -. Basic Motif. Además hay paquetes para utilizar ficheros en formato HTML o RTF. Objetos de acción (DFWLRQ REMHFWV): Estos objetos cuando están activados (HQDEOHG) controlan las acciones de varios objetos componentes de la interfaz. Son hijos de $FWLRQ/LVWHQHU Contenedores anidados: Cualquier componente puede estar anidado en otro. Así la clase 3DQHO de AWT tiene una clase -3DQHO en Swing. Además el usuario puede crear tipos de bordes personalizados. Todas las clases explicadas en el apartado "IV. Arquitectura Modelo-Vista-Controlador: Esta arquitectura da lugar a todo un enfoque de desarrollo muy arraigado en los entornos gráficos de usuario realizados con técnicas orientadas a objetos. Diálogos personalizados: Se pueden crear multitud de formas de mensajes y opciones de diálogo con el usuario. Se puede crear un modelo de datos personalizado para cada componente. se presentan campos de sintaxis oculta -3DVVZRUG.Guía de iniciación al lenguaje Java. Por ejemplo. De hecho todas las clases componentes de Swing (clases hijas de -&RPSRQHQW). Window Win32). Clases para diálogos habituales: Se puede utilizar -)LOH&KRRVHU para elegir un fichero. Gestión mejorada de la entrada del usuario: Se pueden gestionar combinaciones de teclas en un objeto . Componentes para tablas y árboles de datos: Mediante las clases -7DEOH y -7UHH. Bordes complejos: Los componentes pueden presentar nuevos tipos de bordes.H\6WURNH y registrarlo como componente. por ejemplo en %UDLOOH. Octubre de 1999 Œ Aspecto modificable (ORRN DQG IHHO): Se puede personalizar el aspecto de las interfaces o utilizar varios aspectos que existen por defecto (Metal Max. un gráfico se puede anidar en una lista. la ventana en que se encuentra o algún hijo del componente. Soporte a la accesibilidad: Se facilita la generación de interfaces que ayuden a la accesibilidad de discapacitados. y -&RORU&KRRVHU para elegir un color.3$/(6 &/$6(6 Las clases de Swing se parecen mucho a las de AWT. Capacidad para "deshacer": En gran variedad de situaciones se pueden deshacer las modificaciones que se realizaron.1&. mediante la clase -2SWLRQ3DQH. Página 128 de 189 . con sólo heredar de la clase 0RGHO. Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ & 35.QWHUQDO)UDPH.0. son hijas de la clase &RPSRQHQW de AWT. Esto se cumple para todas las clases menos para &KRLFH &DQYDV )LOH'LDOJRJ y 6FUROO3DQH. Potentes manipuladores de texto: Además de campos y áreas de texto. y texto con múltiples fuentes -7H[W3DQH. El evento se activará cuando se pulse dicha combinación si está siendo utilizado el componente. Versión 2. Cada componente tiene asociado una clase de modelo de datos y una interfaz que utiliza. Escritorios virtuales: Se pueden crear escritorios virtuales o "interfaz de múltiples documentos" mediante las clases -'HVNWRS3DQH y -.

pero al ser pinchado por el usuario queda activado. -$SSOHW: Aunque ya existía una clase $SSOHW en AWT. -3URJUHVV%DU: Representa una barra de estado de progreso. mediante la que habitualmente se muestra el desarrollo de un proceso en desarrollo (ejemplo: la instalación de una aplicación). Para estudiarlas consulte la documentación del JDK 1.Guía de iniciación al lenguaje Java. Por ejemplo: laJApplet. Por orden de cercanía al usuario. menús emergentes y otros componentes que deben aparecer flotando entre el usuario y el contenido. Versión 2. -7DEEHG3DQH: Es una ventana con solapas (la que utiliza Windows). pero está disponible como una opción en otros componentes. Página 129 de 189 .0. OD\HUHG3DQH: Una subclase de -&RPSRQHQW diseñada para contener cuadros de diálogo. FRQWHQ3DQH: La capa en que se dibujará la mayor parte del contenido. PHQXEDU: Una capa opcional. Entre ellos conviene destacar los siguientes: Œ %R[/D\RXW: Es similar al )ORZ/D\RXW de AWT. Octubre de 1999 Œ %XWWRQ*URXS: Muestra una lista de elementos (-5DGLR%XWWRQ) con solo uno seleccionable. -7RJJOH%XWWRQ: Es como un botón normal. ' 18(926 *(6725(6 '( . sino que posee muchas más con diversas funcionalidades. estas capas son: Œ Œ JODVV3DQH: Una capa que abarca toda la parte visible (por defecto no es visible).2 de Java. Œ Œ Œ Œ Por supuesto Swing no se limita a estas clases. Œ Œ Así pues cada vez que se vayan a añadir componentes a una DSSOHW de clase -$SSOHW.Ï1 Swing incorpora nuevos gestores de impresión. que en caso del elemento seleccionado contendrá un "punto". con la diferencia de que con él se pueden especificar los ejes (x o y).035(6. esta nueva versión es necesaria para crear DSSOHWV Java que utilicen interfaces Swing. Viene incorporada en el componente %R[.getContentPane(). 6FUROO3DQH/D\RXW: Incorporado en el componente 6FUROO3DQH 9LHZSRUW/D\RXW: Incorporado en el componente 9LHZSRUW Œ Œ Œ Œ ( -52273$1( La clase -5RRW3DQH permite colocar contenido de las DSSOHWV creadas con la clase -$SSOHW en un determinado plano de impresión (capa). Cada elemento tiene un círculo. Este componente había sido muy solicitado. que si aparece estará anclada en la parte superior. debe añadirse a uno de estas capas. 6SULQJ/D\RXW: El espacio se asigna en función de una serie de restricciones asociadas con cada componente.add( unComponente ). ampliando los cinco que AWT incorporaba. 2YHUOD\/D\RXW: Todos los componentes se añaden encima de cada componente previo.

Versión 2. D.0. Octubre de 1999 ) 18(926 (9(1726 '( 6:.Guía de iniciación al lenguaje Java.1* Swing incorpora su nuevo conjunto de eventos para sus componentes.

0HQX'UDJ0RXVH(YHQW: Un menú de árbol ha recibido un evento de 0RXVH(YHQW (pulsación de una tecla).QSXW(YHQW: Œ Œ 0HQX. (YHQWRV ItVLFRV Sólo aparecen dos nuevos eventos físicos. descendientes de . E.H\(YHQW: Un menú de árbol ha recibido un evento de .H\(YHQW (acción sobre el ratón).

&KDQJH(YHQW: Un componente ha sufrido un cambio de estado. &DUHW(YHQW: El signo de intercalación del texto ha cambiado. 7DEOH&ROXPQ0RGHO(YHQW: El modelo para una columna de tabla ha cambiando. 7DEOH0RGHO(YHQW: El modelo de una tabla ha cambiado. 7UHH6HOHFWLRQ(YHQW: La selección de un árbol ha cambiado de estado. * (/ 3$75Ï1 '( '. 7UHH0RGHO(YHQW: El modelo de un árbol ha cambiado. (YHQWRV VHPiQWLFRV Son todos hijos del evento de AWT $:7(YHQW. .QWHUQDO)UDPH(YHQW: Un $:7(YHQW que añade soporte para objetos -. que es el evento base de la jerarquía de eventos: Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ Œ $QFHVWRU(YHQW: Antecesor añadido desplazado o eliminado. Vista: Muestra la información del modelo Página 130 de 189 . 0HQX(YHQW: Un elemento de menú ha sido seleccionado o mostrado o bien no seleccionado o cancelado. 7UHH([SDQVLRQ(YHQW: El nodo de un árbol se ha extendido o se ha colapsado. 'RFXPHQW(YHQW: Un documento ha sufrido un cambio de estado.QWHUQDO)UDPH /LVW'DWD(YHQW: El contenido de una lista ha cambiado o se ha añadido o eliminado un intervalo. 3RSXS0HQX(YHQW: Algo ha cambiado en -3RSXS0HQX. 8QGRDEOH(GLW(YHQW: Ha ocurrido una operación que no se puede realizar. El concepto de este patrón de diseño se basa en tres elementos: Œ Œ Modelo: Almacena el estado interno en un conjunto de clases. /LVW6HOHFWLRQ(YHQW: La selección de una lista ha cambiado.6(f2 02'(/29.67$&21752/$'25 Muchos de los componentes Swing están basados en un patrón de diseño denominado "Modelo-Vista-Controlador". +\SHUOLQN(YHQW: Algo relacionado con un vínculo hipermedia ha cambiado.

Guía de iniciación al lenguaje Java. Versión 2. pero si se quiere profundizar en él consulte >0RUJDQ @. Página 131 de 189 . No es menester de este tutorial explicar todo el funcionamiento de este nuevo diseño.0. Octubre de 1999 Œ Controlador: Cambia la información del modelo (delegado).

17(51(7 Página 132 de 189 . Octubre de 1999 7(0$ 9 -$9$ ( .0.Guía de iniciación al lenguaje Java. Versión 2.

sí conviene tener presente su existencia: Œ Œ Œ Œ MDYDVTO: Paquete que contiene el JDBC. aunque estén codificados en distintos lenguajes.PDJHQ  (MHFXFLyQ GH XQ FyGLJR GH E\WH Esta forma de trabajar cuida la seguridad sin un grave perjuicio de la eficiencia. Conviene destacar la existencia de otras bibliotecas más complejas.0. MDYDQHW: Clases para redes.17(51(7 $ .Guía de iniciación al lenguaje Java. Versión 2. Octubre de 1999 9 -$9$ ( .Ï1 Una de las grandes potencias del lenguaje de programación Java es la total portabilidad de sus programas gracias a su afamada “máquina virtual”. Dan acceso a TCP/IP. comunicarse con ellos e incluso enviar objetos como parámetros de un objeto a otro. que aunque no serán estudiadas en este tutorial. MDYDUPL: Paquete RMI. VRFNHWV y URLs. Estos programas &yGLJRV GH E\WH no necesitan ser recompilados. similar al RMI pero en CORBA. Las siguientes bibliotecas de la API de Java contienen una serie de clases que son interesantes de cara a la creación de aplicaciones que trabajen en red. orientadas también a la programación en red. para localizar objetos remotos. se transforman en direcciones físicas de la máquina destino. . y una vez verificados (pues Java trabaja con nombres no con direcciones). para conexión de programas Java con Bases de datos. RUJRPE&RV1DPLQJ : Da servicio al IDL de Java. Un programa en Java es sólo unas 20 veces más lento que uno programado en C.1752'8&&. Las más importantes son: Œ Œ MDYDDSSOHW: Da soporte a las applets. RUJRPJ&25%$: Facilita la posibilidad de utilizar OMG CORBA. Esto adquiere una importancia aún mayor en Internet donde existen tipos de computadoras muy dispares. cifra Página 133 de 189 . Una de las características de Java que lo hacen especialmente interesante para Internet es que sus programas objeto (códigos de byte) son verificables para poder detectar posibles virus en sus contenidos. para la conexión entre objetos distribuidos.

Octubre de 1999 aceptable para la mayoría de las tareas. Por ejemplo -DYDIDT-DYDIDTKWP. Página 134 de 189 . & )87852 '(/ -$9$ (1 .. y suponiendo que no se utilice un compilador JIT. en lugar de invertir nuestro dinero en actualizaciones. Por ejemplo +773. Incluso siendo un poco más futuristas. Versión 2. trabajando siempre con la última versión del mismo. % (/ 3$48(7( -$9$1(7 Java ofrece un conjunto de clases que permiten utilizar los URLs (8QLIRUP 5HVRXUFH /RFDWRUV).Guía de iniciación al lenguaje Java. El nombre del fichero en el servidor.) en función del tiempo de uso. Un URL es una dirección electrónica que permite encontrar una información en Internet especificando: Œ Œ Œ El nombre del protocolo que permitirá leer la información. podríamos plantearnos conectarnos a servidores que nos cobraran por el uso de sus programas (hojas de cálculo. sino que él sea un conjunto de applets que se descarguen de Internet según se vayan necesitando. Así es que en todo momento podríamos estar ejecutando la última versión del navegador.. Por ejemplo VXQVLWHXQFHGX o bien una dirección IP directamente. El nombre del servidor que proporciona la información. podría evolucionar hasta el punto de que el navegador no interprete las applets de Java. De hecho.0.17(51(7 Java es seguramente el lenguaje con más futuro en cuanto a la programación para Internet. procesadores de texto.

0. Versión 2. Octubre de 1999 9 /26 62&.Guía de iniciación al lenguaje Java. y finalmente para desconectarse. . para leer o escribir y publicar información en él. Utilizan una serie de primitivas para establecer el punto de comunicación. para conectarse a una máquina remota en un determinado puerto que esté disponible para escuchar en él. Página 135 de 189 . Los VRFNHWV han de ser capaces de utilizar el protocolo de streams TCP (Transfer Contro Protocol) y el de datagramas UDP (User Datagram Protocol). un VRFNHW es un punto de comunicación por el cual un proceso puede emitir o recibir información. Fueron popularizados por %HUFNOH\ 6RIWZDUH 'LVWULEXWLRQ. Con todas primitivas se puede crear un sistema de diálogo muy completo.(76 (1 -$9$ $ )81'$0(1726 Los VRFNHWV son un sistema de comunicación entre procesos de diferentes máquinas de una red.PDJHQ  )XQFLRQDPLHQWR GH XQD FRQH[LyQ VRFNHW Para más información véase >5LIIOHW @. de la universidad norteamericana de Berkley. Más exactamente.

D. Octubre de 1999 % (-(03/2 '( 862 Para comprender el funcionamiento de los VRFNHWV no hay nada mejor que estudiar un ejemplo. El que a continuación se presenta establece un pequeño diálogo entre un programa servidor y sus clientes.Guía de iniciación al lenguaje Java. que intercambiarán cadenas de información.0. Versión 2.

close().out.QSXW6WUHDP. } } public static void main( String[] arg ) { new Cliente(). Una vez conectado. lee una cadena del servidor y la escribe en la pantalla: import java. } catch( Exception e ) { System.readUTF() ). skCliente. static final int PUERTO=5000.*. Puerto ). DataInputStream flujo = new DataInputStream( aux ).println( flujo.net. } } En primer lugar se crea el VRFNHW denominado VN&OLHQWH. Luego se asocia el flujo de datos de dicho VRFNHW (obtenido mediante JHW.getMessage() ).println( e.*. System.io. InputStream aux = skCliente. class Cliente { static final String HOST = "localhost". import java.out.getInputStream(). public Cliente( ) { try{ Socket skCliente = new Socket( HOST . al que se le especifican el nombre de KRVW (+267) y el número de puerto (3257) en este ejemplo constantes. 3URJUDPD &OLHQWH El programa cliente se conecta a un servidor indicando el nombre de la máquina y el número puerto (tipo de servicio que solicita) en el que el servidor está instalado.

De dicho flujo capturamos una cadena ( UHDG87) .). que es asociado a un flujo (IOXMR) 'DWD.QSXW6WUHDP de lectura secuencial.

una vez finalizadas las operaciones. ). mediante el método FORVH . y la imprimimos por pantalla (6\VWHPRXW). El VRFNHW se cierra.

Página 136 de 189 .. Debe observarse que se realiza una gestión de excepción para capturar los posibles fallos tanto de los flujos de datos como del VRFNHW.

Guía de iniciación al lenguaje Java. Versión 2.0. Octubre de 1999 E.

y después finalizará su ejecución. 3URJUDPD 6HUYLGRU El programa servidor se instala en un puerto determinado. a las que tratará mediante un segundo VRFNHW. a la espera de conexiones. Cada vez que se presenta un cliente. le saluda con una frase "Hola cliente N". Este servidor sólo atenderá hasta tres clientes. pero es habitual utilizar bucles infinitos ( ZKLOH WUXH.

DataOutputStream flujo= new DataOutputStream( aux ).println("Demasiados clientes por hoy").out.io. y un objeto de la clase 6RFNHW (VN&OLHQWH. import java. OutputStream aux = skCliente.out. para que atiendan llamadas continuamente.* . ) { Socket skCliente = skServidor. System. Tras atender cuatro clientes.getOutputStream(). flujo.println("Sirvo al cliente " + numCli). class Servidor { static final int PUERTO=5000.out. } catch( Exception e ) { System. el servidor deja de ofrecer su servicio: import java. } } public static void main( String[] arg ) { new Servidor().close(). ) en los servidores. } // Cierra while System. numCli < 3. } } Utiliza un objeto de la clase 6HUYHU6RFNHW (VN6HUYLGRU).writeUTF( "Hola cliente " + numCli ). skCliente. // Crea objeto System.* . public Servidor( ) { try { ServerSocket skServidor = new ServerSocket( PUERTO ). numCli++.getMessage() ).out. que sirve para esperar las conexiones en un puerto determinado (38(572).println("Escucho el puerto " + PUERTO ).accept().net. for ( int numCli = 0.println( e.

que sirve para gestionar una conexión con cada cliente. Página 137 de 189 .

Octubre de 1999 Mediante un bucle IRU y la variable QXP&OL se restringe el número de clientes a tres. Para atender a los clientes se utiliza la primitiva DFFHSW . Versión 2. se atiende y se incrementa el contador. con lo que cada vez que en el puerto de este servidor aparezca un cliente.0.Guía de iniciación al lenguaje Java.

que es una rutina que crea un nuevo 6RFNHW (VN&OLHQWH) para atender a un cliente que se ha conectado a ese servidor. Se asocia al VRFNHW creado (VN&OLHQWH) un flujo (IOXMR. de la clase 6HUYHU6RFNHW.

de salida 'DWD2XWSXW6WUHDP de escritura secuencial. en el que se escribe el mensaje a enviar al cliente. El tratamiento de las excepciones es muy reducido en nuestro ejemplo. tan solo se captura e imprime el mensaje que incluye la excepción mediante JHW0HVVDJH .

F..

el servidor ya ha cortado la conexión. Los mecanismos de comunicación pueden ser refinados cambiando la implementación de los VRFNHWV. con lo que se lanza una excepción. obteniendo: >java Cliente Hola cliente 1 >java Cliente Hola cliente 2 >java Cliente Hola cliente 3 >java Cliente connection refused: no further information Mientras tanto en la ventana del servidor se ha impreso: Sirvo al cliente 1 Sirvo al cliente 2 Sirvo al cliente 3 Demasiados clientes por hoy Cuando se lanza el cuarto de cliente. mediante la utilización de las clases abstractas que el paquete MDYDQHW provee. Para ellos se ha de colocar el servidor en una ventana. (MHFXFLyQ Aunque la ejecución de los VRFNHWV está diseñada para trabajar con ordenadores en red. Página 138 de 189 . obteniendo lo siguiente: >java Servidor Escucho el puerto 5000 En otra ventana se lanza varias veces el programa cliente. en sistemas operativos multitarea (por ejemplo Windows y UNIX) se puede probar el correcto funcionamiento de un programa de VRFNHWV en una misma máquina. Obsérvese que tanto el cliente como el servidor pueden leer o escribir del VRFNHW.

Versión 2. Octubre de 1999 7(0$ 9.0.Guía de iniciación al lenguaje Java. $33/(76 -$9$ Página 139 de 189 .

Guía de iniciación al lenguaje Java.0. ya que evitarán que se cargue por error una DSSOHW que destruya datos de la máquina. Las DSSOHWV Von ejecutadas en la máquina cliente.1752'8&&.Ï1 $ /$6 $33/(76 $ . ya que presentan las siguientes diferencias respecto a las aplicaciones normales Java: Se cargan mediante un navegador.. Java tiene muchas salvaguardas de seguridad que minimizan el riesgo de la ejecución de applets. Estas restricciones de seguridad son especialmente importantes. de ahí su potencia. % &216. cuando un usuario instala una copia de un navegador Web en una máquina se está fiando de que su código será Página 140 de 189 . no siendo lanzados por el intérprete Java. Las DSSOHWV pueden ser visualizadas con la herramienta DSSOHWYLHZHU. que obtenga información restringida. mientras que una aplicación se lanza una vez. ni lanzar programas. Este ejecutable puede obtenerse de una red. lo que significa que hay código posiblemente no fiable que se ejecuta dentro de la aplicación. Tienen menos derechos que una aplicación clásica. Son cargados a través de la red por medio de páginas HTML y no residen en el disco duro de la máquina que los ejecuta. A las páginas que contienen DSSOHWV se las denomina páginas -DYD3RZHUHG. Las DSSOHWV son programas que se incluyen en las páginas Web. pero estas salvaguardas también limitan a los programadores de DSSOHWV en su capacidad de programación. Para que esto ocurra tan sólo hace falta que el navegador sea capaz de interpretar Java.21(6 62%5( /$ 6(*85.'$' (1 /$6 $33/(76 Como ya se ha dicho las applets tienen una serie de restricciones de programación que las hacen "seguras". como puede ser un visualizador de páginas Web (EURZVHU). por razones de seguridad. incluido en el JDK de Java. Las DSSOHWV no son exactamente aplicaciones Java. Poseen un ciclo de vida diferente.Ï1 Las DSSOHWV (miniaplicación) son programas escritos en Java que sirven para “dar vida” a las páginas Web (interacción en tiempo real. Versión 2.1752'8&&. Sólo pueden comunicarse con el servidor Web en que se encuentra la página Web que las contiene.. . Octubre de 1999 9. inclusión de animaciones. ni cargar DLLs. con lo que no existen ralentizaciones por la saturación del módem o del ancho de banda. Las DSSOHWV no dejan de ser “ejecutables” que funcionan dentro de una aplicación. o que produzca otros daños inesperados. Permiten cargar a través de la red una aplicación portable que se ejecuta en el navegador.'(5$&.). sonidos. De modo predeterminado en el puesto que los ejecuta no pueden ni leer ni escribir ficheros. Por ejemplo. una DSSOHW se arranca (inicia) cada vez que el usuario recarga la página en la que se encuentra la DSSOHW. El modelo de seguridad para las DSSOHWV en Java trata una DSSOHW como código no fiable ejecutándose dentro de un entorno fiable.

Página 141 de 189 . Sólo cuando estas restricciones son satisfechas se le permite a la DSSOHW ejecutar su código. Cuando se ejecuta. La actual política de seguridad afecta a los recursos que una DSSOHW puede usar. una DSSOHW está restringida en los KRVWV en los que se puede abrir una conexión de red o en un conjunto de URLs a las que puede acceder. El lenguaje Java y las DSSOHWV son escritos para que eviten las DSSOHWV no fiables. por el contrario. Estas salvaguardas son implementadas para verificar que los códigos de byte de las clases de los applets. Versión 2.Guía de iniciación al lenguaje Java. En el futuro. código no revisado o ambos. cuyos principales puntos son: Œ Los accesos que pueden realizar las DSSOHWV a los ficheros son restringidos. En particular escribir en ficheros y/o leerles no será una capacidad estándar que se pueda realizar en los navegadores que soporten DSSOHWV de Java. Octubre de 1999 funcional en el entorno. Una DSSOHW. Una DSSOHW no es capaz de usar ningún método que pueda resultar en una ejecución arbitraria. Esta marca permite a las clases de tiempo de ejecución determinar cuándo a una fracción del código se le permite invocar a cierto método. Java tendrá políticas más ricas.0. no rompen las reglas básicas del lenguaje ni las restricciones de acceso en tiempo de ejecución. Por ejemplo. se carga desde la red sin ninguna comprobación de su fiabilidad. Normalmente los usuarios tienen cuidado de qué instalan cuando proviene de una red. se le marca para señalar que se encuentra dentro del intérprete. Œ Œ Se anticipa en cualquier caso que en el futuro los modelos de seguridad permitirán a las DSSOHWV autentificadas superar estas restricciones. En su conjunto estas restricciones constituyen una política de seguridad. Esto incluye métodos que ejecuten programas arbitrarios (métodos nativos) así como la carga de bibliotecas dinámicas. Las conexiones de red serán restringidas a conectar solo con el KRVW del que proviene la DSSOHW. incluyendo algunas que usen encriptación y autentificación para permitir a las DSSOHWV una mayor capacidad.

que simplemente se ejecuta hasta que finaliza su método PDLQ . '( -$9$ La clase $SSOHW Java. que son dos clases del paquete gráfico AWT.&/2 '( 9.78$&. es la única clase que contiene el paquete MDYDDSSOHW de la API de Java. Esta clase hereda de 2EMHFW (como todas las clases Java).'$ Como ya se ha indicado una DSSOHW no tiene un ciclo de vida tan "sencillo" como el de una aplicación. /$ &/$6( $33/(7 $ 6. Versión 2.Ï1 '( /$ &/$6( $33/(7 (1 /$ $3. pero además hereda de &RPSRQHQW y &RQWDLQHU.0. Esto ya perfila las posibilidades gráficas de este tipo de aplicaciones Java. Octubre de 1999 9. % 0e72'26 '(/ &.Guía de iniciación al lenguaje Java. de la cual han de heredar todos los programas Java que vayan a actuar como DSSOHWV.

Cada fase está marcada con una invocación a un método de la DSSOHW: Œ Œ YRLG LQLW . Las flechas representan transiciones y el texto representa la acción que causa la transición. La siguiente figura modeliza el ciclo de vida de una DSSOHW: .PDJHQ  &LFOR GH YLGD GH XQD DSSOHW Cada círculo representa una fase en el ciclo de vida de la DSSOHW..

 Es invocado cuando se carga la DSSOHW. YRLG VWDUW . Aquí se suelen introducir las iniciaciones que la DSSOHW necesite.

YRLG VWRS .. ha sido parada (cambio de página Web.).. restauración del navegador.. minimización del navegador.. y de nuevo activada (vuelta a la página.Es invocado cuando la DSSOHW. Se informa a la DSSOHW de que tiene que empezar su funcionamiento. después de haber sido cargada..)..

YRLG GHVWUR\ . Es invocado para informar a la DSSOHW de que debe de parar su ejecución. Así una DSSOHW que utilice WKUHDGV. debería detenerlos en el código de este método.

es decir el usuario abandona el navegador.Es invocado para informar a la DSSOHW de que su espacio está siendo solicitado por el sistema. La DSSOHW debe de aprovechar este momento para liberar o destruir los recursos que está utilizando. Œ Œ Página 142 de 189 .

Octubre de 1999 Œ YRLG SDLQW .Guía de iniciación al lenguaje Java.0. Versión 2.

. De hecho habrá DSSOHWV que no los necesiten... mediante su método LQLW . Es invocado cada vez que hay que el navegador redibuja la DSSOHW. 2. Esto indica que la DSSOHW. starting. Al crear una DSSOHW no es necesario implementar todos estos métodos. Cuando un navegador carga una página Web que contiene una DSSOHW.. se está cargando: 1. Una instancia de la clase DSSOHW es creada. suele mostrar en su parte inferior un mensaje como: initializing. La DSSOHW es iniciada.

La DSSOHW empieza a ejecutarse.. 3. mediante su método VWDUW .

que contiene una DSSOHW y salta a otra página. entonces la DSSOHW se detiene invocando a su método VWRS .. Cuando el usuario se encuentra con una página Web.

Si el usuario retorna a la página donde reside la DSSOHW.. ésta vuelve a ejecutarse nuevamente invocando a su método VWDUW .

. Cuando el usuario sale del navegador la DSSOHW tiene un tiempo para finalizar su ejecución y hacer una limpieza final. mediante el método GHVWUR\ .

Además. que como mínimo han de presentar dos parámetros: Página 143 de 189 . La clase 85/ pertenece al paquete MDYDQHW. debe incluirse entre el código HTML de la página Web una etiqueta $33/(7!. que como mínimo ha de presentar los siguientes tres parámetros: Œ Œ Œ FRGH: Especifica el URL del fichero de clase Java (*. KHLJWK: Especifica la altura inicial de la DSSOHW (en SL[HOV).. una DSSOHW puede tener parámetros que se especificarán mediante etiquetas 3$5$0!.host. página Web. una vez compilada la DSSOHW. puesto que muchos de los métodos de la clase $SSOHW la utilizan para acceder a determinado recurso de Internet o para identificarse. imagen.) tiene uno propio. de la etiqueta inicial.1&/86. Ambos ejemplos corresponderían al URL "KWWSZZZKRVWFRPGLUILFKKWP".htm”). Cada recurso (fichero.1$ :(% Para incluir una DSSOHW en una página Web. “dir/fich.com/dir/fich. width: Especifica la anchura inicial de la DSSOHW (en SL[HOV). y tiene una cierta importancia en el desarrollo de las DSSOHWV.Javasoft.Ï1 '( /$ $33/(7 (1 81$ 3È*. En Java existe una clase denominada 85/ que modeliza esta clase de objetos. URL URLrelativo = new URL( URLhost.. O bien podemos especificar un 85/ de manera relativa: URL URLhost = new URL(“http://www.com/”).htm”).. Podemos especificar un URL de manera absoluta: URL URLabsoluto = new URL(“http://www. & /$ &/$6( 85/ Un URL (Uniform Resource Locator) es una dirección de Internet.class) que contiene la DSSOHW. ' .

( 2%7(1&. Esto sucede porque HTML es un lenguaje pareado. YDOXH: Establece este valor al parámetro indicado en QDPH de la misma etiqueta. en el que casi todas las etiquetas de inicio de elemento (HWLT!) tienen una etiqueta de fin (HWLT!). permitiendo a la DSSOHW recibir parámetros de ejecución.class" width=200 height=200> <param name=Parametro1 value=Valor1> <param name=Parametro2 value=Valor2> </applet> Así un ejemplo de esto sería: En este ejemplo la DSSOHW puede entender los parámetro 3DUDPHWUR y 3DUDPHWUR.Guía de iniciación al lenguaje Java.Ï1 '( /26 3$5È0(7526 '( /$ $33/(7 Cuando se incluye una DSSOHW en una página Web ha de hacerse mediante la etiqueta HTML DSSOHW!. y la etiqueta DSSOHW! hace lo propio. mediante los métodos que se describen en el siguiente apartado. tal y como una aplicación los recibe en el parámetro V (un vector de cadenas) de su método PDLQ 6WULQJ>@ V. Se observa que además de la etiqueta DSSOHW! en el código HTML también aparece una etiqueta DSSOHW!. y obtendría 9DORU y 9DORU respectivamente. Octubre de 1999 Œ Œ QDPH: Indica el nombre del parámetro de la DSSOHW al que esta etiqueta hace referencia. <applet code="AppletDiagonal. Las etiquetas HTML permiten utilizar parámetros.0. Versión 2.

 Los siguientes métodos se utilizan para extraer información de los parámetros que recibió la DSSOHW cuando fue llamada desde el código HTML: Œ Œ Œ 85/ JHW'RFXPHQW%DVH .

85/ JHW&RGH%DVH . Devuelve el URL del documento que contiene la DSSOHW.

6WULQJ JHW3DUDPHWHU 6WULQJ QDPH. Devuelve el URL de la DSSOHW.

con el código HTML: Una llamada en esta DSSOHW al método JHW3DUDPHWHU ³&RORU´. Devuelve el valor de un parámetro (etiquetas SDUDP!) que aparezca en el documento HTML. <applet code=”AppletParam.class” width=50 height=50> <param name=Color value=”red”> </applet> Si por ejemplo se llamase a una DSSOHW.

Ï1 62%5( 81$ $33/(7 Algunos métodos de la DSSOHW se utilizan para comunicar información o mostrar mensajes en la pantalla referentes a la DSSOHW: Œ Œ ERROHDQ LV$FWLYH .1)250$&. devolverá ³UHG´. ) 2%7(1&.Ï1 '( .

YRLG VKRZ6WDWXV 6WULQJ VWDWXV. Comprueba si la DSSOHW está activa.

 Muestra una cadena del estado en la pantalla. Página 144 de 189 .

0.QIR . Octubre de 1999 Œ Œ 6WULQJ JHW$SSOHW. Versión 2.Guía de iniciación al lenguaje Java.

. Devuelve información relativa a la DSSOHW como el autor.QIR . 6WULQJ> @> @ JHW3DUDPHWHU. Copyright o versión.

Ï1 '(/ (172512 '( 81$ $33/(7 Algunas applets pueden afectar al entorno en que están ejecutándose. Un ejemplo de como definir este método para una DSSOHW que permita un solo parámetro. Cada elemento en el vector es un vector de tres cadenas que tienen la forma: {nombre.“String”. return info. } * 0$1.38/$&.“foreground color”} }. comentario}. Devuelve un vector que describe algún parámetro específico de la DSSOHW. Para ello se utilizan los métodos: Œ Œ Œ Œ $SSOHW&RQWH[W JHW$SSOHW&RQWH[W . tipo. sería: public String[][] getParameterInfo() { String info[][] = { {“Color”. color.

YRLG UHVL]H LQW DQFKR LQW ODUJR. que permite a la DSSOHW afectar a su entorno de ejecución. Devuelve un $SSOHW&RQWH[W.

/RFDOH JHW/RFDOH . Solicita que se modifique el tamaño de la DSSOHW. También permite recibir un único parámetro 'LPHQVLRQ.

YRLG VHW6WXE $SSOHW6WXE V . Devuelve el /RFDOH de la DSSOHW si fue establecido.

$ La clase $SSOHW también incluye métodos para trabajar con imágenes y ficheros de sonido de Internet mediante la utilización de URLs.PDJH JHW. Establece el VWXE de esta DSSOHW. + 623257( 08/7. Para ello implementa los métodos: Œ Œ Œ Œ .PDJH 85/ X 6WULQJ V.0('.

 Obtiene una imagen de un URL X que será absoluto si no se especifica una ruta relativa V. $XGLR&OLS JHW$XGLR&OLS 85/ X 6WULQJ V.

YRLG SOD\ 85/ XU 6WULQJ QDPH. Obtiene un clip de sonido de un URL X que será absoluto si no se especifica una ruta relativa V.

VWDWLF DXGLR&OLS QHZ$XGLR&OLS 85/ X. Ejecuta directamente un fichero de sonido de un URL X que será absoluto si no se especifica una ruta relativa V.

 Obtiene un nuevo fichero de sonido del URL X. Mediante el uso adecuado de varios de estos métodos se pueden combinar sonidos e imágenes para conseguir efectos espectaculares. Página 145 de 189 .

*2 Para crear una DSSOHW normalmente será necesario importar al menos las bibliotecas MDYDDZW y la MDYDDSSOHW . para poder sobreescribir los métodos de la clase $SSOHW.0.Ï1 '( 81$ $33/(7 $ &Ï'. La clase que represente a la DSSOHW se ha de declarar como una subclase de la clase $SSOHW. Siempre conviene sobreescribir al menos el método SDLQW . Versión 2. (-(03/2 '( &216758&&. Octubre de 1999 9.Guía de iniciación al lenguaje Java.

que será llamado por los navegadores que soporten DSSOHWV para mostrarles por pantalla. import java. public class AppletDiagonal extends Applet { public void paint(Graphics g) { g. } } Pasemos a comentar el funcionamiento de este código: Œ Œ Œ El método SDLQW . getWidth().red ).*. getHeight() ). Un posible código para esta DSSOHW sería: import java.*. 0.drawLine(0. Vamos a construir una DSSOHW denominada $SSOHW'LDJRQDO que simplemente dibuje una línea diagonal.setColor( Color.applet. g.awt.

recibe un objeto de la clase *UDSKLFV. incluida en el AWT. contiene métodos para mostrar varios tipos de gráficos. La clase *UDSKLFV. Mediante el método VHW&RORU .

que es uno de los colores predefinidos de la clase &RORU. mediante GUDZ/LQH . de la clase *UDSKLFV se establece el color de primer plano a rojo. Por último.

y la esquina inferior derecha se obtiene mediante dos métodos de la clase 'LPHQVLRQ ( JHW:LGWK . En este caso se indican la esquina superior izquierda de la DSSOHW mediante las coordenadas (). se dibuja una línea dadas las coordenadas de su esquina superior izquierda y de la inferior derecha.

 JHW+HLJKW .

una vez compilado el fichero. se introduce la llamada a la DSSOHW en una página Web (por ejemplo $SSOHW'LDJRQDOKWP). introduciendo entre su código HTML lo siguiente: <applet code="AppletDiagonal. ). % (-(&8&.Ï1 Para ejecutar la DSSOHW.class" width=200 height=200> </applet> Página 146 de 189 .

Guía de iniciación al lenguaje Java.0. Versión 2. Octubre de 1999 Cuando se cargue esta página Web en un navegador compatible con Java o mediante el visualizador de DSSOHWV que viene con el JDK (DSSOHWYLHZHU) se verá algo como: .PDJHQ  $SSOHW “Línea” Se podría dibujar un rectángulo con cambiar la línea de código de GUDZ/LQH .

por otra que llamase al método GUDZ5HFW .

' &5($&. escapa a las intenciones de este tutorial.Ï1 '( $33/(76 0È6 $9$1=$'$6 La creación de DSSOHWV complejos.drawRect(10.: g. r. Para más información consulte >YDQ +RII HW DO @.&( /$ $33/(7 $:7.height –20). & &5($&. puesto que se incluye su código fuente. 10.&$&./.Ï1 '( 81$ $3/. r.Ï1 48( 87. El dominio de la biblioteca AWT es una condición imprescindible para la creación de DSSOHWV de más calidad y vistosidad. con lo que no se va a presentar el código fuente de más DSSOHWV.width –20. Por último recordar que con el JDK se incluyen unas cuantas DSSOHWV que pueden servir para el estudio de las mismas.

De hecho el PDLQ . Será una aplicación que creará un )UDPH de AWT para incluir en su interior la DSSOHW que ya fue creada. Se va a utilizar AWT para crear una aplicación que de un resultado igual que la ejecución de la DSSOHW /tQHD .

de la aplicación lo único que hará será crear un objeto de este tipo (indicándole altura y anchura.awt. class FrameLinea extends Frame { private AppletDiagonal unaApplet.awt.*. // Se mostrará Página 147 de 189 . El código fuente de la aplicación sería el siguiente: import java. como hacíamos en la DSSOHW mediante los parámetros de la etiqueta HTML).event.*. import java.

Guía de iniciación al lenguaje Java. Versión 2. La aplicación lo que hace es crear un oyente de la clase creada 2\HQWH/LQHD. setSize(ancho. } } } Vamos a crear un )UDPH en el que vamos a incluir la DSSOHW XQD$SSOHW que será de la clase $SSOHW'LDJRQDO.start().exit(0). 230 ). que será el encargado de capturar el evento de cerrar la ventana del )UDPH. // muestra frame } // Clase anidada class OyenteLinea extends WindowAdapter { // Sobreescribo el método de "cuando se cierra ventana" public void windowClosing(WindowEvent e) { unaApplet.stop().0. System.init(). En el constructor se inicia la DSSOHW (LQLW . unaApplet. creada anteriormente. Octubre de 1999 public static void main( String[] s ) { new FrameLinea( 200.destroy(). // Se mete la applet en frame add( unaApplet ).largo). // ajusta frame setVisible(true). int largo ) { super(). // Constructor de Component // Se añade un oyente que cerrara la aplicación addWindowListener( new OyenteLinea() ). unaApplet. // Se crea una applet de diagonal unaApplet=new AppletDiagonal(). } public FrameLinea( int ancho. unaApplet.

y VWDUW .

) y se añade al )UDPH mediante el método DGG .

Por último se establece el tamaño del )UDPH (recibido por parámetro) mediante VHW6L]H . de la clase &RQWDLQHU ()UDPH es hija de &RQWDLQHU).

y por último se muestra el )UDPH que ya tiene en su interior la DSSOHW (VHW9LVLEOH .

el 2\HQWH/LQHD se encarga de cerrar la DSSOHW mediante VWRS .). Cuando se cierra la ventana.

y GHVWUR\ .

 y de finalizar la aplicación mediante 6\VWHPH[LW .

. Página 148 de 189 .

0. Versión 2.Ï1 '( 81$ $3/.&$&.Guía de iniciación al lenguaje Java. Octubre de 1999 ( &5($&.&( /$ $33/(7 6:.1*./.Ï1 48( 87.

Se han de cambiar los nombres de la clase )UDPH de AWT por la clase -)UDPH de Swing. 2. 3. Página 149 de 189 . 4. Se ha de incluir la biblioteca de Swing: import javax.swing. justo antes de llamar al oyente: setContentPane( new JPanel() ). Se crea un FRQWHQW3DQH mediante un objeto -3DQHO. Para añadir la DSSOHW se ha de añadir al FRQWHQW3DQH: getContentPane().*.add( unaApplet ). Esta misma aplicación se puede crear utilizando Swing con solo cambiar las siguientes cosas: 1.

(´ . En cada uno de ellos se ha incluido una descripción de lo que hace la DSSOHW. Animación y Sonidos: Mezclan imágenes con sonidos. Juegos y Educacionales: Muy especializados. Versión 2.QVWDQWiQHD ³7XPEOLQJ 'XNH´ D. (-(03/26 '( $33/(76 En este apartado se comentan una serie de DSSOHWV que pueden servir tanto para demostrar las posibilidades de estos programas. A continuación veremos un ejemplo de cada grupo que sea lo más significativo posible. que resalte las características de ese grupo y las diferencias con el resto de los grupos. $ .1* '8. los parámetros que soporta. y otros elementos ilustrativos de este género. es decir.Guía de iniciación al lenguaje Java.PDJHQ  $SSOHW . Financias y Negocios: Algunos nos permiten mostrar diagramas de barras. Octubre de 1999 9. Gráficos Interactivos: Permiten la interacción del usuario con las imágenes. permiten al usuario interactuar consiguiendo cotas fascinantes de diversión. mediante respuestas a las acciones del ratón sobre la imagen.0.167$17È1($6 ³780%/. y un ejemplo del código HTML que habría que insertar en una página Web para incluir la DSSOHW en dicha página. como para clasificarles por los siguientes géneros: Œ Œ Œ Œ Œ Œ Instantáneas: Muestran una secuencia de imágenes. Trucos de Texto: Permiten animar texto dándole ‘vida’. Demos.

'HVFULSFLyQ Se trata de una DSSOHW en la que 'XNH la mascota de Java. E. da volteretas en la página correspondiente. La animación consta de 17 secuencias.

Página 150 de 189 .. QLPJV: Número de marcos o secuencias en la animación.gif.. T2.gif. 3DUiPHWURV Œ Œ Œ Œ PD[ZLGWK: Anchura máxima de la imagen durante la animación. LPJ: URL del directorio donde se encuentran almacenadas las diferentes secuencias de la animación: T1. RIIVHW: Desplazamiento horizontal entre la primera y la última secuencia de la animación.

Octubre de 1999 F. Versión 2.Guía de iniciación al lenguaje Java.0.

'2 ³$1.0$725´ .PDJHQ  $SSOHW GH $QLPDFLyQ \ VRQLGR ³$QLPDWRU´ D. (MHPSOR <applet code=”TumbleItem.Ï1 < 621.class” width=600 height=95> <param name=maxwidth value=”120”> <param name=nimgs value=”16”> <param name=offset value=”-57”> <param name=img value=”tumble”> </applet> % $1.0$&.

'HVFULSFLyQ Esta DSSOHW permite crear una animación con sonido. E... Haciendo otro continúa la ejecución. otros sonidos para determinadas secuencias. si la animación se repite. el espacio de tiempo entre secuencias. una imagen por defecto mientras se está iniciando la DSSOHW. Haciendo un FOLF con el ratón sobre la DSSOHW se detiene la animación. la pista de sonido. la posición exacta en la que se quiere que aparezca cada secuencia. Se puede especificar el orden de las secuencias.

Cada número se encuentra separado por el carácter |. SDXVHV: Lista de las pausas en milisegundos. Cada número se separa mediante el carácter |. HQGLPDJH: Índice de la última secuencia de la animación.. Su valor por defecto es WUXH.. Permite mover la animación alrededor. Se una para repetir la secuencia de animaciones. 3DUiPHWURV Œ Œ Œ Œ Œ Œ Œ Œ Œ LPDJHVRXUFH: URL del directorio que contiene las imágenes de la animación: T1. Cada par de coordenadas se separa por el carácter |. Permite especificar una pausa específica para cada secuencia. SRVLWLRQV: Coordenadas de la posición de cada marco o secuencia (x@y). VWDUWXS: URL de la imagen que aparecerá por defecto mientras se cargan el resto de las secuencias. EDFNJURXQG: URL de la imagen de fondo. VWDUWLPDJH: Índice de la primera secuencia. Página 151 de 189 . LPDJHV: Índices de las imágenes.gif. UHSHDW: Indicador de repetición. Permite repetir las imágenes de la animación.

VRXQGV: Lista de URLs de archivos de sonido para cada secuencia de la DSSOHW. F.Guía de iniciación al lenguaje Java. Octubre de 1999 Œ Œ Œ VRXQGVRXUFH: URL del directorio que contiene los archivos de sonido. Se encuentran separados por el carácter |. VRXQGWUDFN: URL del archivo de sonido que suena “de fondo”.0. Versión 2.

1.17(5$&7. %87721´ .&26 .926 ³/. (MHPSOR <applet code=Animator.class width=64 height=64> <param name=imagesource value=”tower”> <param name=endimage value=2> <param name=soundsource value=”audio”> <param name=soundtrack value=spacemusic.au|2.PDJHQ  $SSOHW GH JUiILFRV LQWHUDFWLYRV ³/LQN %XWWRQ´ D.au> <param name=sounds value=”1.au”> <param name=pause value=200> </applet> & *5È).

.. o se reproducirá un determinado archivo de sonido.. 'HVFULSFLyQ Esta DSSOHW permite colocar un botón en una página Web. E. Cuando se pulse el botón aparecerá una nueva página.

3DUiPHWURV Œ KUHI: URL del documento o archivo al que hay que llamar cuando un usuario pulsa el botón. Este URL también puede hacer referencia a una posición concreta de la página actual. Œ F. VQG: URL del archivo de sonido que se va a reproducir cuando se pulse el botón.

(MHPSOR <applet code=LinkButton.Javasoft.Java width=100 height=30> <param name=lbl value=”Java”> <param name=href value=http://www.com/> Página 152 de 189 .

7´ .au”> </applet> ' 758&26 '( 7(.Guía de iniciación al lenguaje Java.PDJHQ  $SSOHW GH WH[WR DQLPDGR ³1HUYRXV 7H[W´ D. Versión 2. Octubre de 1999 <param name=snd value=”computer.72 ³1(59286 7(.0.

E. 'HVFULSFLyQ Esta DSSOHW muestra una línea de texto en la que las letras. se están desplazando de tal forma que se superponen con las letras contiguas. muy llamativo. por otra parte. Es algo muy sencillo pero. aleatoriamente.

3DUiPHWURV Œ WH[W: El texto (sólo una línea) que se mostrará en la DSSOHW. F.

class” width=200 height=50> <param name=text value=”hello World!”> </applet> G. (MHPSOR <applet code=”NervousText.

$6 < 1(*2&.PDJHQ  $SSOHW GH ILQDQFLDV \ QHJRFLRV ³%DU &KDUW´ Página 153 de 189 . 1RWDV Se necesitará establecer bien la anchura de la DSSOHW para que quepa toda la línea.1$1&. ( ). Puede servir para una firma en los mensajes de correo electrónico o de noticias. pero no podrá verse si el navegador no soporta Java.26 ³%$5 &+$57´ .

Versión 2. Octubre de 1999 D.Guía de iniciación al lenguaje Java.0.

'HVFULSFLyQ Esta DSSOHW muestra un gráfico de barras basado en los parámetros que recibe. E.

. 3DUiPHWURV Œ Œ Œ Œ Œ Œ Œ Œ WLWOH: Título del gráfico.amarillo. rosa. RULHQWDWLRQ: Posición de las barras: horizontales o verticales. Aparecerá debajo de las gráficas.. F. F1!BYDOXH: Unidades de medida: dólares. días. VFDOH: Escala de representación (en pixels por unidad de barra). tiempo. magenta . azul. F1!BVW\OH: Textura de las barras: lisas o rayadas. FROXPV: Número de columnas (barras) en el gráfico... naranja.. F1!BFRORU: Color de la barra: verde.. F1!BODEHO: Etiqueta de la barra: dinero.

(MHPSOR <applet code=”Chart.class width=251 height=125> <param name=title value=”Performance”> <param name=columns value=”4”> <param name=orientation value=”horizontal”> <param name=scale value=”5”> <param name=c1_style value=”striped”> <param name=c1 value=”10”> <param name=c1_color value=”blue”> <param name=c1_label value=”Q1”> <param name=c2_color value=”green”> <param name=c2_label value=”Q2”> <param name=c2 value=”20”> <param name=c2_style value=”solid”> <param name=c3 value=”5”> <param name=c3_style value=”striped”> <param name=c3_color value=”magenta”> <param name=c3_label value=”Q3”> <param name=c4 value=”30”> <param name=c4_color value=”yellow”> <param name=c4_label value=”Q4”> <param name=c4_style value=”solid”> Página 154 de 189 .

Guía de iniciación al lenguaje Java.0. Versión 2. Octubre de 1999 G.

21$/(6 ³*5$3+ /$<287´ . ) -8(*26 < ('8&$&.PDJHQ  $SSOHW GH MXHJRV \ HGXFDFLRQDOHV ³*UDSK /D\RXW´ D. Sólo se muestra en pantalla. 1RWDV Si se modifica la orientación (poniéndola en vertical) habrá que escoger una anchura y altura adecuadas para que todo el gráfico quepa dentro de la zona reservada para la DSSOHW. El usuario no puede interactuar con el gráfico.

consistente en un conjunto de nodos y arcos. Se pueden definir los nodos que se van a usar así como la longitud óptima de los arcos. E. 'HVFULSFLyQ Es una DSSOHW que despliega un grafo. El grafo está construido mediante un algoritmo heurístico.

3DUiPHWURV Œ Œ Œ FHQWHU: Nodo central del grafo (en color rojo) que se sitúa en el centro de la pantalla. Este parámetro consiste en una lista (separada por comas). HGJHV: Arcos del grafo. de arcos. Los nodos se crean cuando se necesitan. donde la longitud del arco (ORQJLWXG) es opcional F. Cada arco se define mediante un par de nodos entre las etiquetas RULJHQ GHVWLQRORQJLWXG.

joe-tea. food-mouse/100. plate-food/30.class" width=400 height=400> <param name=edges value="joe-food. joe-cat. food-dog/100. joe-dog. Página 155 de 189 . joe-table. mouse-cat/150. tab1e-cup/30. (MHPSOR <applet code="Graph. table-plate/50.

dog-cat/80. Octubre de 1999 cup-tea/30.Guía de iniciación al lenguaje Java. p1ate-knive”> <param name=center value="joe"> </applet> G. dog-fleal. f1ea1-f1ea2/20. Versión 2. plate-fork. dog-f1ea2.0. cup-spoon/50.

1RWDV El usuario puede recoger nodos y distorsionar el grafo para acelerar el proceso del esquema. Página 156 de 189 .

Guía de iniciación al lenguaje Java. Versión 2.&(6 Página 157 de 189 . Octubre de 1999 $3e1'.0.

LW.Guía de iniciación al lenguaje Java. (/ -'.&( . -DYD 'HYHORSPHQW . Octubre de 1999 $3e1'. Versión 2.0.

es decir Kit de desarrollo de Java. utilidades.1752'8&&. D. Para la realización de este tutorial se ha trabajado con la versión 1. Se puede definir como un conjunto de herramientas. $ .Ï1 JDK es el acrónimo de "Java Development Kit".2. documentación y ejemplos para desarrollar aplicaciones Java. % &20321(17(6 '(/ -'.0 del JDK.

. Se observará que todos los programas permiten la inclusión de una serie de opciones sobre su ejecución antes del primer argumento. indicando entre corchetes aquellos elementos que sean opcionales.QWURGXFFLyQ JDK consta de una serie de aplicaciones y componentes. Estas opciones se indican precedidas de un menos(-): programa -opcion1 -opcion2 Parametro1 Todas las opciones que los ejecutables del JDK presentan se muestran llamando al programa sin parámetros o con las opciones " o KHOS: programa programa -help programa -? E. así como su sintaxis. para realizar cada una de las tareas de las que es capaz de encargarse A continuación se explican más en profundidad cada uno de ellos.

QWpUSUHWH HQ WLHPSR GH HMHFXFLyQ -5(. .

&ODVH$(MHFXWDU: Especifica el nombre de la clase cuyo método PDLQ . Permite la ejecución de los programas Java (*.class) no gráficos (aplicaciones). La sintaxis para su utilización es la siguiente: java [Opciones] ClaseAEjecutar [Argumentos] Œ Œ 2SFLRQHV: Especifica opciones relacionadas con la forma en que el intérprete Java ejecuta el programa.

Si la clase reside en un paquete se deberá especificar su ruta mediante en forma SDTXHWHVXESDTXHWHFODVHBDBHMHFXWDU. $UJXPHQWRV: Especifica los argumentos que se recibirán en el parámetro V del método PDLQ 6WULQJ V. se desea ejecutar como programa.

y una ruta destino. por si el programa necesita de parámetros de ejecución. probablemente nos interese recibir como argumento la ruta del fichero a filtrar. Œ Página 158 de 189 .. Si por ejemplo el programa realiza el filtrado de un archivo.

Versión 2.0. Octubre de 1999 F.Guía de iniciación al lenguaje Java.

en archivos de clases Java ejecutables (*.class). G. $UFKLYR$&RPSLODU: Especifica la ruta del archivo fuente a compilar. Se crea un archivo de clase para cada clase definida en un archivo fuente. normalmente una fichero con extensión MDYD . &RPSLODGRU Se utiliza para compilar archivos de código fuente Java (habitualmente *. Este compilador es una utilidad en línea de comandos con la siguiente sintaxis: javac [Opciones] ArchivoACompilar Œ Œ 2SFLRQHV: Especifica opciones de cómo el compilador ha de crear las clases ejecutables.java).

visualizando cómo se mostrarían en un navegador. 9LVXDOL]DGRU GH DSSOHWV Es una herramienta que sirve como campo de pruebas de applets. H. Al ser activado desde una línea de órdenes abre una ventana en la que muestra el contenido de la DSSOHW. Se activa con la sintaxis: appletviewer [Opciones] Applet Œ Œ 2SFLRQHV: Especifica cómo ejecutar la applet Java. $SSOHW: Indica un URL o una ruta de disco que contiene una página HTML con una applet Java empotrada. en lugar de tener que esperar.

Se activa con la sintaxis: jdb [Opciones] Œ 2SFLRQHV: Se utiliza para especificar ajustes diferentes dentro de una sesión de depuración. No es un entorno de características visuales. 'HSXUDGRU Es una utilidad de línea de comandos que permite depurar aplicaciones Java. Es parecido en su funcionamiento al depurador JGE que se incluye con las distribuciones del compilador JFFJ para C/C++. I. pero permite encontrar y eliminar los errores de los programas Java con mucha exactitud.

muestra los atributos y métodos públicos de la clase desensamblada. Es útil cuando no se tiene el código fuente de una clase de la que se quisiera saber cómo fue codificada. mostrándolos por pantalla. 'HVHQVDPEODGRU GH DUFKLYR GH FODVH Se utiliza para desensamblar un archivo de clase. Página 159 de 189 . Su salida por defecto. pero con la opción F también desensambla los códigos de byte. La sintaxis es la siguiente: javap [Opciones] [NombresClases] Œ 2SFLRQHV: Especifica la forma en la que se han de desensamblar las clases.

Octubre de 1999 Œ 1RPEUHV&ODVH: Especifica la ruta de las clases a desensamblar.0. Versión 2.Guía de iniciación al lenguaje Java. separadas por espacios. J.

crea los ficheros de cabecera C/C++ para implementar en esos lenguajes los métodos nativos que presente un programa Java. *HQHUDGRU GH FDEHFHUD \ DUFKLYR GH DSpQGLFH Se utiliza para generar archivos fuentes y cabeceras C para implementar métodos Java en C (FyGLJR QDWLYR). La sintaxis es la siguiente: javah [Opciones] NombreClase Œ Œ 1RPEUH&ODVH: Nombre de la clase desde la cuál se van a generar archivos fuente C. Esto se consigue mediante la generación de una estructura C cuya distribución coincide con la de la correspondiente clase Java. El generador de cabeceras MDYDK. 2SFLRQHV: Forma en la que se generarán los archivos fuente K.

del que generar documentación. aparecerán resaltadas en la documentación generada. La documentación que genera es del mismo estilo que la documentación que se obtiene con el JDK. que se indican con una arroba (#). Las etiquetas. *HQHUDGRU GH GRFXPHQWDFLyQ Es una herramienta útil para la generación de documentación API directamente desde el código fuente Java. Su sintaxis es: javadoc Opciones NombreArchivo Œ Œ 2SFLRQHs: Opciones sobre qué documentación ha de ser generada. 1RPEUH$UFKLYR: Paquete o archivo de código fuente Java. con el formato  FRPHQWDULRV : /** Comentarios sobre la clase @autor: Ignacio Cruzado */ class MiClase { }. Genera páginas HTML basadas en las declaraciones y comentarios MDYDGRF. L.

M. $SSOHWV GH GHPRVWUDFLyQ El JDK incluye una serie de applets de demostración. con su código fuente al completo.

aunque permanece en formato comprimido en un archivo llamado "VFU]LS" localizado en el directorio Java que se creó durante la instalación. El código fuente de la API se instala de forma automática. Página 160 de 189 . &yGLJR IXHQWH GH OD $3. cuando se descomprime el JDK.

notepad) Página Web con applet incrustado: Pagina. vi.0. Ya se han visto las diferentes partes de que está compuesto el JDK. Versión 2. En el siguiente diagrama podemos ver la sucesión de pasos para generar un programa final Java: Edición del fuente: Editor de Textos (edit.html . deberemos utilizar las diferentes herramientas que nos proporciona el JDK en un orden determinado.PDJHQ  8WLOL]DFLyQ GHO -'. vi.class Inserción de métodos nativos: javah Ficheros de cabecera C/C++ fichero.Guía de iniciación al lenguaje Java. pero para el desarrollo de una aplicación final Java (ya sea una aplicación o una DSSOHW). Página 161 de 189 . notepad) Codigo Fuente Java MiClase.h Ejecución del programa: java MiClase Salida del programa Ejecución del applet: appletviewer MiClase Editor de Textos (edit. Octubre de 1999 & 862 '(/ -'.java Documentación automática: javadoc Documentación HTML sobre MiClase Compilación: javac MiClase Codebyte Java: MiClase.

Ï1 ( .Guía de iniciación al lenguaje Java. por favor consulte a su fabricante.4 SPARC o 2.167$/$&. ( 129('$'(6 (1 /$ 9(56. La instalación es diferente para cada sistema operativo.6 sobre x86 o SPARC.0. IBM AIX.Ï1  '(/ -'. El JDK se puede obtener de las páginas de Sun (KWWSMDYDVXQFRP). pues Sun tiene previsto desarrollar su JDK para más plataformas.5 al 2. OS/400 y OS/390 Linux Si su sistema operativo no ha sido enumerado. y existen versiones disponibles para varias plataformas entre las que se encuentran: Œ Œ Œ Œ Microsoft Windows 95 y NT 4. -$9$ . Versión 2.0 Sun Solaris 2.Ï1 '(/ -'. Se recomienda observar y establecer los valores de las variables de entorno: Œ Œ 3$7+: Variable de entorno que indica desde qué ruta (además del directorio actual) se pueden ejecutar los programas &/$663$7+: Indica al compilador Java en qué rutas se encuentran los ficheros de clase. Octubre de 1999 ' 2%7(1&. pero en general muy sencilla.

2 del JDK (diciembre de 1997) significa un salto importante en las capacidades de Java. La aparición de la versión 1. hasta tal punto que comercialmente se conoce a esta evolución como "Java 2". D.

E.. &ODVHV Se amplía el paquete de clases de JFC(Java Foundation Classes) pasando de 23 a 70 clases.. Aparecen nuevos paquetes de la API Java: Œ Œ Œ 6ZLQJ: Nuevo paquete de gráficos. -DYD &ROOHFWLRQV: Incluye nuevas clases que representan estructuras de datos clásicas de la programación: 9HFWRU $UUD\/LVW $UUD\6HW 7UHH0DS. -DYD ': Ampliación de AWT.

que compilan las clases para las plataformas locales. especialmente utilizando los nuevos compiladores Just In Time (JIT). tanto en código como en ejecución. Compilador más estricto y que genera un código más optimizado. Mejor tratamiento de sonido. (ILFLHQWH HMHFXFLyQ Œ Œ Œ Compatible con programas realizados en otras versiones. incorporados en las nuevas JRE. Œ Œ Página 162 de 189 . soporte para certificados X509v3 y nuevas herramientas y certificados de seguridad. próximo a la velocidad de ejecución de C++. aumentando su velocidad de ejecución. Entorno de ejecución más rápido y estable (máquina virtual). Mejora en la gestión de la seguridad: Control de acceso basado en el plan de acción.

Y por supuesto se solventan errores de versiones pasadas. F. Versión 2.Guía de iniciación al lenguaje Java. Octubre de 1999 Œ Œ Más velocidad de las clases que utilizan RMI.0.

Los JavaBeans se pueden incluir unos en otros. -DYD%HDQV Œ Œ Œ -DYD 3OXJLQ: Permite que las applets y los JavaBeans de una red utilicen el JRE 1.2. Se permite a los JavaBeans interactuar con applets y se les da un mejor soporte en tiempo de diseño y en tiempo de ejecución. G. en vez de la máquina virtual del navegador en que se muestren.

'/ . 2WURV ΠΠΠ.QWHUIDFH 'HILQLWLRQ /DQJXDJH.

: Para interactuar con CORBA de una forma simple y práctica se utiliza Java. -&( -DYD &ULSWRJUDSK\ ([WHQVLRQV.

QYRFDWLRQ. 50.: Se ofrecen mejores posibilidades para el tratamiento seguro de la información. 5HPRWH 0HWKRG .

incluso mediante SSL (Security Socket Layer) un conocido sistema de seguridad de comunicación. Tecnología de ayuda. Œ Œ Œ H.: Permite realizar acciones sobre objetos remotos. Mejor soporte de DUUDVWUDU \ VROWDU. Otros servicios varios.

2EVHUYDFLRQHV Aunque no existen incompatibilidades importantes. No se recomienda la utilización de ILQDOL]H^` en la gestión de excepciones. El paquete 6ZLQJ en algunas versiones intermedias aparecía colgando de FRPVXQMDYD o de MDYDDZWVZLQJ y ahora pasa a ser MDYD[VZLQJ . Página 163 de 189 . SULYDWH. sí que se pueden observar que algunas cosas que en otras versiones no funcionaban bien o se permitían ahora se desaprueban. Entre otros conviene destacar: Œ Œ Œ No se pueden declarar métodos abstractos como QDWLYH. ILQDO ni V\QFURQ]HG.

Guía de iniciación al lenguaje Java.&( . Versión 2..Ï1 D.0.(17$6 '( '(6$552//2 $ 352*5$0$6 '( 1$9(*$&. +(55$0. Octubre de 1999 $3e1'.

que afortunadamente se han comprometido a apoyarlo.QWURGXFFLyQ Las applets Java no serían de mucha utilidad sin programas de navegación compatibles con Java. E. para que Java funcione necesita de estos programas de navegación. Por lo tanto. .

Para más información consultar http://home. que es un lenguaje de comandos basado en objetos Java. también ha ayudado en el desarrollo de -DYD6FULSW.es. Además del simple apoyo al lenguaje y sistema de tiempo de ejecución.netscape.com/ F. 1HWVFDSH 1DYLJDWRU Es un programa de navegación con apoyo completo a Java. El objetivo de -DYD6FULSW es permitir el desarrollo rápido de aplicaciones distribuidas cliente servidor.

Para más información consultar http://www.microsoft. y está completamente integrado en la versión Windows 98 del mismo. Está estrechamente ligado al sistema operativo Microsoft Windows 95.com/ G. 0LFURVRIW .QWHUQHW ([SORUHU Microsoft tardó un poco en desarrollar una herramienta para Java: Internet Explorer.

Se diseñó inicialmente como un experimento en el desarrollo del programa de navegación de Java. Se ha convertido en un prometedor modelo de lo que depara el futuro para los programas de navegación de la Web. +RW-DYD Es el contendiente de Sun. Será el programa de navegación existente más compatible con Java.sun. Para más información consultar http://www. Constituye un útil campo de pruebas para los programadores de Java. Es capaz de gestionar e interactuar de forma dinámica con nuevos tipos de objeto y protocolos Internet.com/ H.

y ya está disponible con apoyo a Java. Para más información consultar http://www.com/ % (1725126 '( '(6$552//2 D. 6S\JODVV 0RVDLF Fue el primer navegador de Internet.spyglass.

Página 164 de 189 . y aunque el JDK es suficiente para desarrollar Java.'(V) para este lenguaje. se han creado muchos entornos de desarrollo (.QWURGXFFLyQ Los desarrolladores se han acostumbrado a las herramientas gráficas de programación. .

Versión 2. E. mientras que otra parte consistirá en productos totalmente nuevos.0.Guía de iniciación al lenguaje Java. y se indican otros por si el lector desea buscar algo con unas características muy específicas. Octubre de 1999 La mayor parte de los participantes en el negocio de herramientas de programación han anunciado algún tipo de entorno de desarrollo para Java. Parte de ese apoyo ha llegado en forma de módulos adicionales para productos ya existentes. En este apartado se comentan algunos de los más valorados.

presentándolas en formato gráfico. lenguaje macro integrado para ampliar el editor. Las principales funciones que soporta son las siguientes: Œ Editor de programación gráfica: Posee todas las características de un moderno editor de programación: sintaxis a todo color. Soporta proyectos dentro de proyectos.. Œ Œ Œ Œ Para más información. Gestor de proyectos: Permite organizar proyectos Java con mayor efectividad. consultar http://cafe. 9LVXDO &DIp GH 6\PDQWHF La empresa Symantec... Integra de forma transparente las herramientas del JDK. dura competidora en los IDE de Java ofrece el entorno visual de desarrollo Java Visual Café. Depurador gráfico: Gran ventaja sobre el MGE que es modo línea. Editor de clases y jerarquías: Navega con rapidez a través del código Java. por lo que puede mantenerse al día con bibliotecas anidadas y dependencias de proyectos. que ya goza de una gran reputación entre los desarrolladores de Java. applets.com/ F. este editor localiza el código fuente correspondiente y lo carga. Asistentes: Para creación de eventos. bases de datos.symantec. resaltado de palabras clave. permitiendo trabajar directamente con clases o miembros de clases en lugar de archivos individuales.. Además gestiona y visualiza las relaciones lógicas entre clases.

y es directo heredero del tan extendido 0LFURVRIW 9LVXDO &. lo que ha llevado a ambas compañías a juicio.microsoft. en lugar de utilizar las clases del JFC.com/ G. rompiendo la portabilidad. Se encuentra incluido en el paquete de desarrollo 0LFURVRIW 9LVXDO 6WXGLR. para el desarrollo en la plataforma Windows. Presenta el serio problema de que no respeta las especificaciones de clases de Sun. 9LVXDO - GH 0LFURVRIW Es la nueva herramienta de Microsoft para desarrollar Java en sus sistemas operativos Microsoft Windows. Microsoft se ha inventado un nuevo paquete WFC(Windows Foundation Classes). Para más información consultar http://www.

-%XLOGHU. -%XLOGHU GH %RUODQG La empresa %RUODQG es la desarrolladora de populares entornos de desarrollo de C++ y Delphi para Windows. Página 165 de 189 . Borland ha optado por desarrollar un producto totalmente nuevo para los desarrolladores de Java.

Para más información. y se distribuye en dos versiones (standard y Cliente/Servidor). Versión 2.0.borland. Realmente es un producto muy completo de desarrollo de Java. consúltese http://www. lo que permite a Borland salir del mercado del PC y comercializar -%XLOGHU en todas las plataformas soportadas por Java. soportando incluso CORBA. Tiene un programa de desarrollo de JavaBeans con más de 200 prediseñados.com/jbuilder/ H.Guía de iniciación al lenguaje Java. Octubre de 1999 -%XLOGHU ha sido desarrollado totalmente en Java. Presenta gran conectividad con las bases de datos.

sun. Es muy fácil crear aplicaciones sencillas con este IDE. Para más información consúltese http://www.com/ I. pero se necesita tener una versión del JDK previamente. y tiene unos requisitos hardware bastante altos. en el que casi la mayoría de las tareas se realizan mediante el ratón. -DYD 6WXGLR GH 6XQ Entorno muy intuitivo y práctico.

9LVXDO$JH IRU -DYD GH . y definiendo el sistema de eventos.%0 Es una RAD (5DSLG $LGGHG 'HVLJQ). que aunque tiene muchas de las características del Visual Café. Es muy sencillo de manejar y uno de los más potentes del mercado.com/ad/vajava/ J. consúltese http://www. la herramienta puede crear código Java. Permite diseñar la interfaz de la aplicación o DSSOHW. con una interfaz un poco más limpia.ibm. Para más información.

http://www.samsung.QWHOOLJHQFH: Entorno de desarrollo Java para Power Macintosh. < PXFKRV PiV Los IDE están en continuo desarrollo.com. Algunos de ellos son: Œ Œ Œ Œ Œ Œ Œ &RGH:DUULRU GH 0HWURZHUNV: Entorno de desarrollo Java para Macintosh. basado en &RGHZDUULRU &.com Página 166 de 189 .PenumbraSoftware. creado por Heechang Choi. http://www.com/page/products/roaster/ &RVPR GH 6LOLFRQ *UDSKLFV: Conjunto de herramientas de desarrollo &RVPR con dos bibliotecas propias.natural. http://www. http://www. http://net.com/products/cosmo/ 6XSHU&HGH GH $V\PHWUL[: Un producto a bajo precio. aunque flojo en otros aspectos.com/ 5RDVWHU GH 1DWXUDO .sgi. http://www. y seguro que tras la finalización de este tutorial ya han aparecido muchos más en el mercado.com. fácil de usar.kr/~hcchoi/Javamaker.au/~saig 0RMR GH 3HQXPEUD 6RIWZDUH: Entorno visual para crear applets.com/sales/ -DYD 0DNHU: Sencillo entorno de desarrollo que funciona bajo Windows 95/NT.html (G GH 6RIW $V .W *HWV: Editor muy potente para Windows. con algunos tutoriales. http://www.asymetrix.ozwmail.metrowerks.info.

JACK: Herramienta para crear applets Java a través de una interfaz sencilla. De hecho ya están apareciendo algunas bibliotecas comerciales de objetos Java. con mucha documentación. & %.27(&$6 '( 352*5$0$&.com/Business_and_Economy/Companies/Computes/Software/PR ogramming_Tools/Languages/Java: Lista de últimas herramientas Java. http://www. la empresa Dimensión X cuenta con tres bibliotecas de clases Java: Ice: Paquete de representación de gráficos tridimensionales. Se recomienda al lector que busque en Internet en las direcciones: Œ Œ http://www.aimtech.developer. Liquid Reality: Kit de herramientas VRML.html: Lista de los entornos de desarrollo preferidos por los desarrolladores de Java.%/. Página 167 de 189 . por lo que es importante no ignorar el potencial de volver a utilizar objetos Java.html La información de este apartado ha sido extraída de >5RMR @ >0RUJDQ @ y >=ROOL @.0. Octubre de 1999 Œ -DPED GH $LP7HFK: Constructor gráfico de applets.com/prodjahome.Guía de iniciación al lenguaje Java. http://www.com/news/userchice/n_userframe. Versión 2.Ï1 Java está orientado a objetos.yahoo. Œ Œ Œ Œ Por ejemplo.

Octubre de 1999 $3e1'..0. Versión 2.&( .Guía de iniciación al lenguaje Java. 0e72'26 1$7..926 -$9$ -1.

Se advierte al lector que no se deje engañar por la simpleza del ejemplo que se va a desarrollar. generalmente escrito en C/C++. algunas de ellas necesitan utilizar la potencia específica de una plataforma en concreto.926 Para mostrar cómo utilizar los métodos nativos. 5. porque la potencia del JNI va mucho más allá de lo que estas líneas dejan entrever. 3. motivo por el que no se permite incluir métodos nativos en DSSOHWV de Java. 2.QYRFDWLRQ). Creación de un archivo de cabecera nativo (K) 4. Así se puede utilizar código específico de una plataforma. Para ello Java cuenta con el JNI (-DYD 1DWLYH . Escritura de los métodos nativos. invocando métodos nativos como QDWLYH. Creación de una biblioteca con esos métodos nativos. vamos a crear un pequeño programa. escrito con métodos nativos.Ï1 Aunque la potencia de la API de Java es más que suficiente para casi todo tipo de aplicaciones. % (-(03/2 '( 862 '( 0e72'26 1$7. bibliotecas ya escritas. Ejecución del programa Java. Hay que tener en cuenta que una aplicación que utilice este tipo de métodos estará violando las directrices de seguridad de la máquina virtual Java. Para agregar métodos nativos Java a una clase de Java han de seguirse los siguiente pasos: 1.. por ejemplo para conseguir un poco más de velocidad y eficiencia. $ . 6. Java permite incorporar en sus programas fragmentos de FyGLJR QDWLYR es decir. Para ello vamos a utilizar el JDK y un compilador de C.. Para más información consulte >0RUJDQ @. D.1752'8&&. código compilado para una determinada plataforma. que lo único que hace es imprimir £+ROD 0XQGR . Compilación del programa Java. Escritura del programa Java.

static { System. (VFULWXUD GHO SURJUDPD -DYD Escribimos el programa Java en un fichero denominado +ROD1DWLYRMDYD.loadLibrary("LibHola"). El código Java que vamos a utilizar será: puclic class HolaNativo{ public native void diHola(). } public static void main( String[] args ) { Página 168 de 189 .

diHola(). } } El método nativo GL+ROD .0. Versión 2. Octubre de 1999 new HolaNativo().Guía de iniciación al lenguaje Java.

no tiene cuerpo porque será añadido mediante una biblioteca nativa denominada /LE+ROD. Dicha biblioteca nativa es cargada mediante la sentencia ORDG/LEUDU\ .

E. El programa principal tan sólo instancia un objeto de esta clase y utiliza el método nativo que imprime la cadena de £+ROD 0XQGR . sentencia que ha sido incluida como VWDWLF para que sea ejecutada cada vez que se cree una instancia (objeto) de esta clase..

java F. &RPSLODFLyQ GHO SURJUDPD -DYD Ahora ya es posible compilar la clase Java +ROD1DWLYR que fue creada mediante la sentencia (utilizando el JDK): javac HolaNativo.

&UHDFLyQ GH XQ ILFKHUR GH FDEHFHUD QDWLYR K.

variables globales. Los métodos nativos suelen denominarse siempre como Java_Paquete_Clase_Metodo() aunque en este caso al no haber paquete esta parte se ha omitido.h> JNIEXPORT void JNICALL Java_HolaNativo_diHola(JNIEnv*. métodos o funciones. La primera línea importa una biblioteca JNI que valdrá a C/C++ para saber cómo crear los métodos nativos.). G.. La herramienta MDYDK incluida en el JDK es capaz de crear automáticamente un fichero de cabecera para métodos nativos Java.(QY y MREMHFW que permitirán al método nativo comunicarse con su entorno. Un fichero de cabecera nativo es un fichero que habitualmente tiene la extensión K . Hay dos líneas importantes dentro de este fichero: #include <jni. La segunda línea corresponde al método nativo que definimos.. En un fichero de este tipo se definen en C/C++ las interfaces públicas (clases. con sólo invocarla indicando el nombre de la clase de la que extraer las cabeceras nativas: javah HolaNativo Esta operación crea un fichero +ROD1DWLYRK que será útil para crear los métodos nativos. Así mismo los métodos nativos reciben como parámetros -1.jobject). constantes.

en el que se defina el cuerpo de la función que actuará como método nativo.h> Página 169 de 189 . Este fichero lo denominaremos +ROD1DWLYRF: #include <jni.h> #include "HolaNativo. (VFULWXUD GH ORV PpWRGRV QDWLYRV Se ha de crear un fichero fuente nativo.h" #include <stdio.

Versión 2. Ser puede observar que el cuerpo del método nativo lo que hace es invocar a la función de C SULQWI .Guía de iniciación al lenguaje Java.0. Octubre de 1999 JNIEXPORT void JNICALL Java_HolaNativo_DiHola( JNIEnv* e. el fichero de cabecera ya creado (+ROD1DWLYRK) y una biblioteca de C para imprimir (VWGLRK). } En este programa se incluyen tres bibliotecas: La de JNI (MQLK). jobject o ){ printf("¡Hola Mundo!!!\n").

que imprimirá por pantalla la cadena £+ROD 0XQGR . H.

Para esto cada compilador tiene su propia sintaxis.c -Fe libHola. En cualquier caso algunos ejemplos de compilación en bibliotecas son: Para el GCC de Solaris: cc -G HolaNativo.so Para Microsoft Visual C++ para Windows: cl -LD HolaNativo. con lo que se tendrá que consultar la documentación del compilador en lo referente a la creación de bibliotecas.c -o libHola. &UHDFLyQ GH XQD ELEOLRWHFD FRQ HVRV PpWRGRV QDWLYRV Cada compilador de C o C++ tiene su propia herramienta para crear bibliotecas compartidas (DLL en Windows o SO en UNIX). y luego crear la biblioteca compartida mediante el programa correspondiente a su compilador.dll En cualquier caso asegúrese que la biblioteca creada tiene el mismo nombre con que se la invoca desde el archivo de clase Java en el método ORDG/LEUDU\ . Para crear la biblioteca se ha de compilar el fichero fuente nativo.

I..

debe invocarse: java HolaNativo Con lo que se muestra por pantalla: Hola Mundo Se puede observar que la forma de creación. solo que al incluir métodos nativos. han de crearse bibliotecas y ficheros de cabecera antes de ejecutar el programa. (MHFXFLyQ GHO SURJUDPD -DYD Para ejecutar este programa. Página 170 de 189 . compilación y ejecución de la clase Java es igual que la utilizada para crear una aplicación Java normal.

así como acceder a los recursos de las máquinas (lo que le permitía atacar sistemas. Sin embargo Java pretende mejorar a C++ en muchos aspectos (sobre todo en los aspectos orientados a objeto del lenguaje).1752'8&&.$6 6. debido mayoritariamente a que Java proviene de C++. Se observa que las diferencias han sido diseñadas como mejoras del lenguaje.$ '( & $ -$9$ $ .0. Versión 2.&( .Guía de iniciación al lenguaje Java. aunque prohibe muchas de las tareas por las que C++ fue tan extendido. siendo uno de los lenguajes más difundidos entre los programadores de virus).17È7. conociendo sus posibilidades y limitaciones. En este apéndice pretendemos mostrar aquellas diferencias significativas. ya que uno de los aspectos más criticado (y defendido) de C++ es su capacidad para hacer cosas “no orientadas a objetos”.&$6 D.9 *8Ë$ '( 5()(5(1&.)(5(1&. Octubre de 1999 $3e1'.Ï1 La sintaxis de Java resulta muy familiar a los programadores de C++. % '. para que los programadores familiarizados con C++ puedan programar en Java.

(OHPHQWRV VLPLODUHV 8VR GH ELEOLRWHFDV SDTXHWHV.

: Como no existen macros como LQFOXGH. &RQVWDQWHV En lugar de FRQVW de C++ las variables constantes se declaran como VWDWLF ILQDO. en lugar del operador :: de C++. se utiliza LPSRUW. E. 2SHUDGRU GH KHUHQFLD: La herencia en Java se especifica con la palabra clave H[WHQGV.

Simplemente se llama el método. 0pWRGRV YLUWXDOHV: Todos los métodos no estáticos (VWDWLF) se consideran YLUWXDO en Java. 0pWRGRV LQOLQH: En Java no existen (hay que incluir el cuerpo de los métodos junto a su definición). )RUZDUG: No existe en Java. sí que se puede modelizar este concepto mediante los paquetes Java y la composición. aunque los compiladores Java suelen intentar expandir en línea (a modo de los métodos inline) los métodos declarados como ILQDO. (OHPHQWRV HTXLYDOHQWHV 0LHPEURV HVWiWLFRV: No es necesaria declaración previa (fuera de las clases) de los miembros estáticos (VWDWLF). 1R H[LVWHQ DPLJRV IULHQG. &ODVHV DQLGDGDV: Aunque Java no permite anidar clases. y el compilador se encarga de buscarlo.

Página 171 de 189 .: Es su lugar se considera amigas a todas las clases y elementos que componen un paquete.

Octubre de 1999 F.0. Versión 2.Guía de iniciación al lenguaje Java.

con la sintaxis  FRPHQWDULR . porque Java solo soporta herencia simple. 5HIHUHQFLD VXSHU: En Java VXSHU hace referencia a la superclase (clase padre) de la clase actual.QLFLDFLyQ: Todos las variables de tipo simple y las referencias a objeto se inician a un valor 0 (o equivalente). (OHPHQWRV DxDGLGRV &RPHQWDULRV: Java soporta los dos tipos de comentarios de C++. y QXOO para las referencias a objeto. . 2SHUDGRU !!! : Java añade este operador para desplazamientos a la derecha con signo. G. e incorpora un tercero. para la documentación automática. Dicha clase sólo puede ser una.

(OHPHQWRV VXSULPLGRV JRWR: No existe en Java. combinados con etiquetas de bloque. aunque con EUHDN y FRQWLQXH.$6 '( '. $UJXPHQWRV SRU GHIHFWR: Java no los soporta.6(f2 D. &RQGLFLRQHV: Deben utilizarse expresiones booleanas y nunca números.)(5(1&. se puede suplir. & '.

3XQWHURV: En Java no hay punteros. En su lugar se crean las referencias a objeto. y ampliando el tipo FKDU. 7LSRV GH GDWRV 7LSRV VLPSOHV: Soporta los mismos que C++. para soportar caracteres Unicode de 16 bits. que pueden ser reasignadas (como si fueran un puntero a objeto de C++). permitiendo así programación segura. añadiendo ERROHDQ (WUXHIDOVH). con un método OHQJWK . 9HFWRUHV: Son objetos de sólo lectura.

no existen enumeraciones (HQXP) ni registros (VWUXFW). aunque se puede utilizar VWDWLF para simularlas. para averiguar su longitud. (OHPHQWRV JOREDOHV: No existen variables o funciones globales. y que lanzan una excepción si se intenta acceder a un elemento fuera del vector. &ODVHV: Todo debe de estar incluído en clases. E.

aunque en su lugar se pueden escribir métodos ILQDOL]H . &RQVWUXFWRUHV: Aunque existen constructores. como en C++. puesto que los argumentos son pasados por referencia. no existen constructores copia. 'HVWUXFWRUHV: No existen destructores en Java. No se pueden separa como se hace en C++ mediante ficheros de cabecera ( K ). 'LVHxR GH ODV FODVHV &XHUSR GH ORV PpWRGRV: Todos los cuerpos de las clases han de estar codificados en las definiciones de las clases. ya que tiene recolección automática de basura.

Página 172 de 189 .. que serán ejecutados cuando el recolector de basura de Java destruya el objeto.

6REUHFDUJD GH RSHUDGRUHV: No existe.Guía de iniciación al lenguaje Java. no se puede reducir las ocultaciones del padre: En C++ sí se podría ampliar la visibilidad de uno de los elementos heredados. En C++ sin embargo se pueden declarar clases que no tengan padre.0. Aún así se puede implementar una herencia múltiple utilizando interfaces. En los objetos 6WULQJ el operador + y += se permiten para la comparación de cadenas. Versión 2. Octubre de 1999 ÈUERO GH KHUHQFLD: En Java todas las clases se relacionan en un único árbol de herencia. +HUHQFLD VLPSOH GH FODVHV: No existe la herencia múltiple de clases. En todo caso sí se puede restringir. 6REUHFDUJD GH PpWRGRV: Es exactamente igual que la de C++. F. +HUHQFLD QR UHVWULFWLYD Al heredar. dado que ellas sí la soportan. con lo que todas las clases heredan de ella. en cuya cúspide se encuentra la clase 2EMHFW.

1XHYRV GLVHxRV 3ODQWLOODV WHPSODWHV.

aunque existen una serie de clases en la API de Java que tratan objetos genéricos (clase 2EMHFW) como 9HFWRU o 6WDFN.: En Java no se soportan plantillas p clases genéricas de C++. .QWHUIDFHV LQWHUIDFH.

$6 '( (-(&8&.: Que son unas especies de FODVHV DEVWUDFWDV con PpWRGRV DEVWUDFWRV. 'LIHUHQWH JHVWLyQ GH H[FHSFLRQHV: Todas las excepciones de Java heredan de la clase 7KURZDEOH.)(5(1&. y que permiten herencia múltiple. ' '. que las dota de una interfaz común. utilizando la palabra reservada LPSOHPHQWV.Ï1 D.

*HVWLyQ GH HUURUHV DO FRPSLODU: Además comprobar el lanzamiento de excepciones en tiempo de compilación. no en vectores estáticos de caracteres. permitiendo al programador gestionar dichos fallos. aunque esta diferencia se está reduciendo con lo compiladores JIT(Just In Time) para Java que están apareciendo en el mercado. comprueba el cumplimiento del lanzamiento de excepciones por los métodos sobreescritos. uso de objetos distribuídos o compresión. . . Java incorpora bibliotecas estándar multiplataforma para todas estas tareas en su API. uso de múltiples hilos de control. Página 173 de 189 .QVWDQFLDFLyQ: Los objetos se crean en el montículo (QHZ) y nunca en la pila (PDOORF). iguales que los de C++). $VSHFWRV PRGLILFDGRV &DGHQDV: Las cadenas entrecomilladas se convierten en objetos 6WULQJ. conexión a bases de datos. y los tipos simples no permiten QHZ (excepto los vectores de tipos simples. y recuperar al programa de ellos. ([FHSFLRQHV SRU IDOORV GH GHVFULSWRUHV: Java lanza excepciones cuando hay errores en el acceso a un descriptor. %LEOLRWHFDV HVWiQGDU: En C++ existía casi una biblioteca por plataforma (si existía) para hacer cosas como: Trabajo en red.QWpUSUHWH: Los intérpretes Java son unas 20 veces más lentos que los de C.

0. Octubre de 1999 E. Versión 2.Guía de iniciación al lenguaje Java.

sólo las aplicaciones Java pueden hacerlo. En cualquier caso las DSSOHWV no pueden utilizar estos PpWRGRV QDWLYRV. aunque para eso permite la utilización de PpWRGRV QDWLYRV. $FFHVR GLUHFWR DO KDUGZDUH: En Java está restringido. escritos para la plataforma (normalmente C/C++). $VSHFWRV HOLPLQDGRV 3UHSURFHVDGRU: Java no tiene preprocesador. F. por lo que las macros ( LQFOXGH GHILQH) no existen.

$VSHFWRV LQWURGXFLGRV 0XOWLSOHV KLORV GH FRQWURO PXOWLWKUHDWLQJ.

([WUDFFLyQ DXWRPiWLFD GH GRFXPHQWDFLyQ: Un nuevo tipo de comentario ( FRPBGRF ) permite a los programadores extraer de manera automática comentarios de sus fuentes.: Java permite la utilización de múltiples hilos de control y la ejecución en paralelo (y sincronizada) de múltiples tareas. $SSOHWV -DYD: Este tipo de aplicaciones son seguras. se permite crear elementos visuales Página 174 de 189 . -DYD%HDQV: Mediante esta biblioteca multiplataforma. distribuíbles por Internet y ejecutables por los navegadores. generando automáticamente documentación estandarizada. aunque tienen restricciones (como la escritura en disco). algo impensable en C++. mediante la clase 7KUHDG.

0. Octubre de 1999 $3e1'. Versión 2.&( 9 *8Ë$ '( 5()(5(1&.Guía de iniciación al lenguaje Java. Propuestas de estilo de nombres de identificadores: Las clases: &ODVH o 0L&ODVH.$ '(/ /(1*8$-( -$9$ $ )81'$0(1726 Palabras reservadas (funcionales): DEVWDFW FDWFK GR ILQDO LPSOHPHQWV ORQJ SULYDWH VWDWLF WKURZ YRODWLOH /*comentario*/ ERROHDQ FKDU GRXEOH ILQDOO\ LPSRUW QDWLYH SURWHFWHG VXSHU WKURZV ZKLOH EUHDN FODVV HOVH IORDW LQVWDQFHRI QHZ SXEOLF VZLWFK WUDQVLHQW E\WH FRQWLQXH H[WHQGV IRU LQW QXOO UHWXUQ V\QFURQLFHG WU\ FDVH GHIDXOW IDOVH LI LQWHUIDFH SDFNDJH VKRUW WKLV YRLG Tipos de comentarios: // Hasta fin de línea //* javadoc */ Bloques de código: { } // conjunto de sentencias Separadores Java: { } . Los métodos: PHWRGR . : .

o PHWRGR/DUJR .

Las constantes: &2167$7( o &2167$17(B/$5*$.326 '( '$726 E\WH VKRUW LQW ORQJ IORDW GRXEOH FKDU ERROHDQ 7LSR E\WHV 1 2 4 8 4 8 2 1 7LSR 'DWRV Entero Entero Entero Entero Coma flotante Coma flotante Caracter Booleano 5DQJR SRVLWLYR. Los paquetes: MDYDSDTXHWHVXESDTXHWH. % 7. Las variables: DOWXUD o DOWXUD0HGLD.

127 32767 2.14e2 ’a’ o \064 WUXH o IDOVH Vectores: int vectorNumeros[]=new int[numero].4e-45 a 3. Página 175 de 189 .6 3.9e-324 a 1.7e308 Unicode WUXH o IDOVH /LWHUDO 14 14 14 14 36.483.4e38 4.147.233e15 1.647 9.

Versión 2.Guía de iniciación al lenguaje Java. & 23(5$'25(6 Operadores Unarios: 2SHUDGRU + Convierte el operador a LQW Niega aritméticamente oper. Octubre de 1999 Cadenas Constates: String nombreBonito = ”Amelia”. Cadenas Variables: StringBuffer cadenaVariable = ”Cambiante”.0. 'HVFULSFLyQ SUHILMD.

2SHUDGRU ++ -- 'HVFULSFLyQ SUH R SRVILMD.

siempre evalúa op1 y op2 OR. siempre evalúa op1 y op2 op es falso Operadores de bit (binarios): 2SHUDGRU !!  !!! _ A a RS !! RS RS  RS RS !!! RS RS RS RS _ RS RS A RS aRS 8VR 2SHUDFLyQ Desplaza los bits de op1 a la derecha op2 veces Desplaza los bits de op1 a la izquierda op2 veces Desplaza los bits de op1 a la derecha op2 veces (sin signo) AND OR "XOR" Complemento Operador terciario: expresion ? sentencia_si : sentencia_si_no Precedencia de operadores: 7LSR GH RSHUDGRUHV Operadores posfijos Operadores unarios Creación o conversión 2SHUDGRUHV GH HVWH WLSR [ ] . Incrementa operador Decrementa operador Operadores aritméticos (binarios): 2SHUDGRU    RS  RS RS  RS RS RS RS  RS RS RS 8VR $WDMR op1 += op2 op1 -= op2 op1 *= op2 op1 /= op2 op1 %= op2 'HVFULSFLyQ Suma op1 y op2 Resta op2 de op1 Multiplica op1 por op2 Divide op1 por op2 Resto de op1 / op2 Operadores de comparación (binarios): 2SHUDGRU > >= < <= == != __ _ 8VR op1 > op2 op1 >= op2 op1 < op2 op1 <= op2 op1 == op2 op1 != op2 RS RS RS RS RS __ RS RS _ RS RS 'HYXHOYH YHUGDGHUR VL op1 es mayor que op2 op1 es mayor o igual que op2 op1 es menor que op2 op1 es menor o igual que op2 op1 y op2 son iguales op1 y op2 son distintos AND. condicionalmente evalúa op2 OR. (parametros) expr++ expr-++expr --expr +expr -expr ~ ! new (tipo) expr Página 176 de 189 . condicionalmente evalúa op2 AND.

} Sentencias de saltos: etiquetaSentencia: sentenciaEtiquetada break nombreEtiqueta. default : } conjuntoDeSentencias. // Hace otra pasada al último bucle Página 177 de 189 . condicion_continuacion. Versión 2. case valor2 : conjuntoDeSentencias.0. }. for(inicio. break. break. case valor3 : conjuntoDeSentencias. break. IRU): while ( expresiónBooleana ) { sentencias. break. Octubre de 1999 Multiplicación Suma Desplazamiento Comparación Igualdad AND a nivel de bit OR a nivel de bit XOR a nivel de bit AND lógico OR lógico Condicional Asignación * / % + << < <= = instanceof == != & ^ | && || ? : = += -= *= /= %= &= ^= |= <<= = = ' (6758&785$6 '( &21752/ Toma de decisión (LIHOVH y VZLWFK): if ( condición ) { Bloque de código a ejecutar si la condición es cierta } else { Bloque de código a ejecutar si no } switch ( expresionMultivalor ) { case valor1 : conjuntoDeSentencias. sentencia_actualizacion) { sentencias. do { sentencias. } while ( expresiónBooleana ).Guía de iniciación al lenguaje Java. Bucles iterativos (ZKLOH. // Sale del último bucle continue. GRZKLOH.

SURWHFWHG: Los miembros declarados SURWHFWHG son accesibles sólo para sus subclases class claseCompuesta { claseComponente referenciaAObjetoComponente. . NombreDeClase{ // Constructor } // . LPSOHPHQWV: Interfaces padres.0. y son heredados por las subclases. separadas por comas. // Sale del método devolviendo YDORU ( &/$6(6 Definición de clase: acceso class NombreDeClase herencia{ acceso tipo nombreAtributo1. } } Tipos de acceso de las clases: Œ Œ Œ Œ Œ ILQDO: Sin subclases DEVWUDFW: Clase abstracta. . Versión 2.%8726 Herencia: Acceso (igual que para métodos): Œ Œ Œ SXEOLF: Los miembros declarados SXEOLF son accesibles en cualquier lugar en que sea accesible la clase. class MiClase extends SuPadre implements Interface0. SULYDWH: Los miembros declarados SULYDWH son accesibles sólo en la propia clase. Octubre de 1999 return valor. La clase 2EMHFW es superclase de todas las clases Java (raíz del árbol de herencia). luego no se permiten instancias de esta clase.QWHUIDFH .QWHUIDFH. finalize { //Recogida de basura } acceso tipo_devuelto nombreMétodo1( parámetros ) { cuerpo_del_método1. . SXEOLF: Accesible desde fuera de su paquete H[WHQGV: Clase padre.Interface1.Guía de iniciación al lenguaje Java. } Composición: Página 178 de 189 . ) $75.

} } Herencia múltiple entre interfaces: interface InterfazMultiple extends Interfaz0. Sobreescritura del método: Un cuerpo en cada nivel de herencia. + 2%-(726 Instanciación: NombreDeClase referenciaAObjeto = new NombreDeClase(). int metodoAbstracto( int p ){ return ( p*m ). V\QFKURQL]HG: Solamente permite un hilo de ejecución.Interfaz1.atributo. DEVWUDFW: Método abstractos. Versión 2. QDWLYH: Método implementado con métodos nativos (específicos de una plataforma). Igual que para los atributos. Sólo se permiten en clases abstractas. Modificadores permitidos: Sobrecarga del método: Varias implementaciones en función de los parámetros. referenciaAObjeto. Acceso al objeto: referenciaAObjeto. . Clases de envoltura de tipos simples: Página 179 de 189 .método( parámetros ). ILQDO: No se puede sobreescribir el método. Octubre de 1999 * 0e72'26 Referencias válidas en los métodos: Œ Œ Œ Œ Œ Œ Œ Œ WKLV: Referencia al objeto actual. sin cuerpo.17(5)$&(6 Declaración de una interfaz: interface MiInterfaz { int CONSTANTE = 100.Guía de iniciación al lenguaje Java. // Por definir } Implementación de interfaces: class ImplementaInterfaz implements MiInterfaz{ int m=CONSTANTE.0. VXSHU: Referencia a la clase padre en el árbol de herencia. int metodoAbstracto( int p ). . VWDWLF: Método de la clase (no de los objetos). Destrucción: Cuando la referencia a objeto sale de ámbito en el programa. Acceso: SXEOLF SULYDWH o SURWHFWHG.

Importación de un paquete o parte de él: import Paquete. pero que se detectan fuera del tiempo de ejecución. 5XQWLPH([FHSWLRQ: Excepciones que se dan durante la ejecución del programa.Subpaquetes1. ([FHSWLRQ: Excepciones no definitivas.0.Subpaquete2.elemento Visibilidad en los paquetes: 6LWXDFLyQ GHO HOHPHQWR (Q OD PLVPD FODVH (Q XQD FODVH HQ HO PLVPR SDTXHWH (Q XQD FODVH KLMD HQ RWUR SDTXHWH (Q XQD FODVH QR KLMD HQ RWUR SDTXHWH .21(6 SULYDWH Sí No No No SRU GHIHFWR SURWHFWHG Sí Sí No No Sí Sí Sí No SXEOLF Sí Sí Sí Sí Tipos de excepciones: Œ Œ Œ (UURU: Excepciones que indican problemas muy graves. Paquete. Versión 2.QWHJHU /RQJ &KDUDFWHU %RROHDQ - 3$48(7(6 IORDW LQW VKRUW E\WH ORQJ FKDU ERROHDQ Creación de un paquete (primera sentencia de un fichero fuente): package NombrePaquete. que suelen ser irrecuperables y no deben casi nunca ser capturadas. (.Guía de iniciación al lenguaje Java.&(3&.Subpaquete2. metodoLanzador() throws MiException{ throw MiException: } Lanzamiento de una excepción: Tratamiento de una excepción: try { // Código posiblemente problematico Página 180 de 189 .Subpaquete1.Clase1. Octubre de 1999 &ODVHV GH HQYROWXUD GH WLSRV VLPSOHV 'RXEOH GRXEOH )ORDW .Clase_o_Interfaz.

0. y crear un objeto de la clase 7KUHDG. Este objeto representará un nuevo hilo de control.Guía de iniciación al lenguaje Java. extendiendo la clase base 5XQQDEOH. que será accionado cuando invoquemos al método VWDUW . se ha de implementar una clase. Octubre de 1999 } catch( tipo_de_excepcion e) { // Código para solucionar la excepcion e } catch( tipo_de_excepcion_mas_general e) // Código para solucionar la excepcion e } finally { // Se ejecutara tras try o catch } / 7+5($'6 Creación: Œ Œ Œ Para crear un WKUHDG. Versión 2.

del WKUHDG. el método UXQ . En ese momento este hilo se activará. ejecutando (si el planificador de hilos considera que es el momento).

Durante la ejecución de un programa. actuando en un determinado orden. de la clase en que todo esto suceda. y de las funciones ZDLW . muchas veces varios procesos han de realizar tareas de una forma sincronizada. Para ello se han de declarar métodos como V\QFURQL]HG Mediante la utilización de excepciones.

y QRWLIL\ .

. respectivamente esperarán a que otro proceso acabe antes de continuar su ejecución. Sincronización de procesos: Œ Œ Œ Página 181 de 189 .

0. Versión 2. Octubre de 1999 */26$5.Guía de iniciación al lenguaje Java.2 $EVWUDFW :LQGRZLQJ 7RRONLW $:7.

ÈPELWR..Biblioteca de módulos pera representar interfaces gráficos provisto por Sun en la API de Java...Parte de la máquina virtual Java responsable de velar por el cumplimiento de las políticas y reglas de seguridad. $GPLQLVWUDGRU GH 6HJXULGDG.QIRUPDWLRQ ..QWHUFKDQJH $6&. $PHULFDQ 6WDQGDUG &RGH IRU .Parte de un programa en el que es válida una referencia a una variable.

$SOLFDFLyQ. que se ejecuta sin necesidad de otro programa $SSOHW. normalmente un navegador..Programa informático. Es una parte del código ANSI que se amplía hasta los 257 caracteres.. $QiOLVLV..Application Programming Interface. $3.Proceso de conocer los requerimientos de software que tienen el cliente y el usuario final..QWHUIDFH $3. $SSOLFDWLRQ 3URJUDPPLQJ ...Sistema de codificación que convierte caracteres a números en el rango de 0 a 127.Programa informático que se ejecuta necesitando de otro programa..

$:7...Parámetros..Conjunto de paquetes y clases Java.Beans Developer Kit.Abstract Windowing Toolkit.. $6&... $UJXPHQWRV.. incluidos en el JDK que utilizan los programadores Java para realizar sus aplicaciones.American Standard Code for Information Interchange. %HDQV 'HYHORSHU . con forma de árbol (nodos padres e hijos).Estructura de datos. $UUD\...Vector.. ÈUERO. grafo no cíclico. %'.LW %'..

&DVWLQJ. Normalmente letras de alfabeto. %LW. Código localizado entre corchetes. Página 182 de 189 .. que puede tomar valor de cierto (WUXH) o falso (IDOVH)... &DGHQD.. %\WH..Parte del JRE de Java responsable de encontrar archivos de clase y cargarlos en la máquina virtual Java. %RROHDQ.Secuencia de caracteres. &*..Tipo de datos bi-estado. números o signos ASCII.Moldeado.... %ORTXH.Símbolo que representa información. &DUJDGRU GH FODVHV. o la codificación en una computadora.Conjunto de herramientas para desarrollar -DYD%HDQV.Secuencia de 8 bits. &DUiFWHU.. Unidad mínima de información digital que puede tomar los valores lógicos de  o de .Common Gateway Interfaz.

que sirve como plantilla para la creación de objetos.0. Una clase define datos y métodos y es la unidad de organización básica de un programa Java. &RPPRQ *DWHZD\ . Octubre de 1999 &ODVH. Versión 2.QWHUID] &*.Unidad fundamental de programación en Java..Guía de iniciación al lenguaje Java.

Los VFULSW FJL pueden estar escritos en cualquier lenguaje de programación.Es un lenguaje de programación que permite dotar a las páginas Web de interactividad... construyendo una página Web correspondiente a un enlace de hipertexto en el mismo momento en que se hace "clic" sobre el enlace. &RPPRQ 2EMHFW 5HTXHVHW %URNHU $UFKLWHFWXUH &25%$.

. Método que tiene el mismo nombre que la clase que inicia. es un objeto que contiene los componentes (como botones.. La garantía es a menudo reforzada por el compilador. (YHQWR. *UDSKLFDO 8VHU .Una construcción de software (en memoria o en disco duro) que contiene datos y las relaciones lógicas entre ellos. normalmente desde fuera del entorno de software. &RQVWDQWH.. que no se pueden expresar como una simple asignación..Stream.QWHIDFH *8. ([FHSFLyQ.Modificación de una expresión de un tipo de datos a otro. &RPSLODGRU... &RQWHQHGRU..Valor utilizado en un programa de computadoras con la garantía de no cambiar en tiempo de ejecución.. sin parte decimal.Programa de software que traduce código fuente en un lenguaje de programación legible por una persona a código máquina interpretable por un ordenador. &RQYHUVLyQ GH WLSRV GH GDWRV. )OXMR. &25%$. aunque esté codificados en distintos lenguajes.Estándar para la conexión entre objetos distribuidos.. Toma cero o más parámetros y proporciona unos datos u operaciones iniciales dentro de una clase. (VWUXFWXUD GH GDWRV.Un número entero.. &RQVWUXFWRU.Un mensaje que significa n incidente importante. barras de deslizamiento y campos de texto)..Un evento que ocurre durante la ejecución de un programa que interrumpe el flujo normal de las instrucciones. (QWHUR. En Java las constantes se declaran como VWDWLF ILQDO. positivo o negativo.Common Object Requeset Broker Architecture. En diseño de interfaces de usuario.

Interfaz gráfica de usuario. disco duro e impresora. sólo existe herencia simple..Mecanismo encargado de relacionar clases entre sí de una manera jerárquica.7KUHDG +70/ +\SHU7H[W 0DUNXS /DQJXDMH. +DUGZDUH. +LOR. En Java....La práctica (permitida en lenguajes como C++ pero no en Java) de derivar una clase de más de una FODVH EDVH +HUHQFLD. como el procesador. +HUHQFLD P~OWLSOH..El aspecto físico de un sistema de computadora..

Página 183 de 189 .Lenguaje que se utiliza para crear páginas Web... Los programas de navegación de la Web muestran estas páginas de acuerdo con un esquema de representación definido por el programa de navegación.

QJHQLHUtD GHO VRIWZDUH.. .0.. Octubre de 1999 .Objeto de software construido desde una clase.QWHJUDO 'HYHORSPHQW (QYLURPHQW . .. Versión 2. prueba. Por ejemplo. puede tener una clase avión.Rama de la ingeniería concerniente con el análisis.QVWDQFLD. y mantenimiento de programas de computadoras. implementación.Java Interface Definition Language.'(. pero una flota de quince instancias de avión.'(. .Integral Development Environment. .'/. diseño.Guía de iniciación al lenguaje Java..

. cada una esperando los recursos que está utilizando la otra.'/.Condición en la que dos o más entidades de software se bloquean mutuamente.Una herramienta de desarrollo visual en la que un programa puede ser construido.QWHUIDFH 'HILQLWLRQ /DQJXDJH .QWHUEORTXHR.. ejecutado y depurado. ...

.QWHUID] JUiILFD GH XVXDULR *8. mediante CORBA...Herramienta mediante la cual los objetos pueden invocar métodos de otros objetos que se encuentren en máquinas remotas.

. que depende de pantallas de alta resolución. Es parte del JMF. el Mac OS. (Esas clases estarán definidas para implementar la interfaz).Paquete que permite a los desarrolladores incorporar texto.QWHUID] Mecanismo Java para decirle al compilador que un conjunto de métodos serán definidos en futuras clases.Conjunto de clases para crear aplicaciones y applets con elementos en tres dimensiones.. imágenes y gráficos en dos dimensiones de gran calidad.Una interfaz entre la máquina y el hombre como el Windows de Microsoft. un recurso gráfico de puntero como un ratón y una colección de controles en pantalla (denominados Widgets) que el usuario puede manejar directamente. -DYD '. o el Sistema X Windows. . -DYD '. -DYD 'DWD%DVH &RQQHFWLYLW\ -'%&...

. -DYD 'HYHORSHU &RQQHFWLRQ -'&.Lenguaje estándar de Java para interactuar con bases de datos. Es independiente no sólo de la plataforma sino también de la base de datos con que interactúe. Desde la versión 1..2 del JDK se permite interactuar con ODBC. similar al SQL.

Conexión de desarrollo en la que se publican las versiones beta de las bibliotecas de Java que se están desarrollando.. -DYD )RXQGDWLRQ &ODVVHV -)&..

Conjunto de componentes y características para construir programas con interfaces gráficas... -DYD 0HGLD )UDPHZRUN -0).

.QYRFDWLRQ -1.. -DYD 1DWLYH .Protocolo de transmisión de datos para la reproducción multimedia (vídeo y sonido).

. No se puede utilizar en applets...Capacidad de Java para ejecutar código nativo.). pues viola las directrices de seguridad. Permite a la Máquina Virtual Java (JVM) interactuar con programas o bibliotecas escritos en otros lenguajes (C/C++. es decir. código compilado al lenguaje máquina de un determinado ordenador. ensamblador. -DYD 5XQWLPH (QYLURQPHQW -5(..

. Página 184 de 189 .Software suministrado por Sun que permite a los programas de Java ejecutarse en una máquina de usuario.. El JRE incluye la Máquina Virtual Java (JVM).

. Versión 2.. -DYD 9LUWXDO 0DFKLQH -90.Guía de iniciación al lenguaje Java. -90.0.Java Virtual Machine.Java Runtime Environment. Octubre de 1999 -5(.

-'&.$SSOHW.Conjunto de sentencias que operan sobre los datos de la clase para manipular su estado... 0XOWLSURFHVR. /ODPDGD SRU YDORU. son populares navegadores de Web. una representación del mundo real en unas abstracciones de software denominadas clases y la relación entre ellas.. la subrutina puede leer y cambiar el valor del elemento referenciado.. 2EMHFW 'DWD%DVH &RQHFWLYLW\ 2'%&. 1DYHJDGRU :HE... 0ROGHDGR. QXOO.Una forma de transferir parámetros a una subrutina en la que se pasa un puntero o referencia a un elemento.Java Foundation Classes.Java DataBase Connectivity. que se puedan incorporar gráficamente a otros componentes.Java Media Framewok -1.Java Virtual Machine. comúnmente en un procesador solo (a través de 0XOWLWDUHD).. Netscape Navigator. de esta forma... -'%&. 1DYHJDGRU.Software que permite al usuario conectarse a un servidor de Web utilizando Hypertext Transfer Protocol (HTTP).Una forma de transferir parámetros a una subrutina en la que se pasa la copia del elemento..En sistemas operativos.Suplantación del tipo de un objeto o variable por otro nuevo tipo.. -90.Navegador Web.. 0pWRGR.El intérprete de Java que ejecuta los códigos de byte en una plataforma particular.. HotJava de Sun.Java Developer Connection..En diseño orientado a objetos. 0LQLDSOLFDFLyQ....Paquete que permite escribir componentes software Java. la habilidad de efectuar dos o más programas independientes. -DYD%HDQV. 0RGHOR. /ODPDGD SRU UHIHUHQFLD... Microsoft Internet Explorer. -)&. -0).. las modificaciones de la copia no afectan al elemento original.Java Native Invocation.Valor de Java que significa YDFtR.

3DUiPHWURV Valores u objetos pasados entre una subrutina y la rutina de llamada.Nombre de Java para una biblioteca de clases. 3DUiPHWURV IRUPDOHV.. Lenguaje estándar de Microsoft.Object DataBase Conectivity. 3DTXHWH. 2'%&... más orientado a C/C++ que a Java.Nombres utilizados dentro de una subrutina por sus parámetros. para interactuar con ella. Página 185 de 189 .. que utiliza un driver del fabricante de una base de datos.

Octubre de 1999 3OXJLQ Un programa de una plataforma específica diseñado para ser llamado por un navegador Web.0. Por ejemplo. la habilidad de utilizar una clase derivada en lugar de su clase base.En diseño orientado a objetos.Guía de iniciación al lenguaje Java. 3ROLIRUILVPR. Utilizado con frecuencia para mostrar información que el mismo navegador no puede mostrar.. un programador puede escribir un método H[SUHVDUVH . Versión 2.

para la clase Mamífero. Un Perro. una Vaca y un Gato se derivan de Mamífero. y todos pueden H[SUHVDUVH .

tiene dos procesos de la máquina virtual de Java ejecutándose en su computadora. 6HXGRFyGLJR. el mecanismo por el cual se recobra y libera la memoria asociada con objetos no utilizados. aunque sus voces sean bastantes diferentes.. 5HPRWH 0HWKRG .Instancia de un programa ejecutable..QYRFDWLRQ 50. Por ejemplo.. 5HFROHFWRU GH EDVXUD.En Java..Documentación de diseño que describe el trabajo de un programa en inglés estructurado (o en otro lenguaje) en lugar de un lenguaje de computadora. si inicia dos copias de un intérprete de Java. 3URFHVR.

.. 6HFXUH 6RFNHWV /D\HU 66/.Herramienta que incorpora métodos Java ara localizar objetos remotos.Remote Method Invocation. comunicarse con ellos e incluso enviar objetos como parámetros de un objeto a otro.. 50..

son ejemplos de sistemas operativos. 6WUHDP.Sistema para la creación de conexiones seguras en red. Windows.. Por ejemplo las entradas y salidas de un programa. 6KHOO.Software responsable de asignar a los usuarios los recursos de sistemas de computadoras (incluyendo procesos).. en vez de a una instancia.Módulos que permiten sustituir o utilizar el lenguaje Java en lugar de programas CGI.Flujo de datos..En diseño orientado a objetos. (VWiWLFR.. 6LVWHPD RSHUDWLYR.. 66/. 64/.. que representa una cadena de caracteres.. 6WULQJ. 6HUYOHWV.Objeto Java estandarizado en el lenguaje. NT y Mac OS. UNIX. Es un espacio compartido por todas las instancias de una clase.. Structured Query Language.Secure Sockets Layer.Intérprete de órdenes de un sistema operativo. representa la pertenencia a la clase.. 6WUXFWXUHG 4XHU\ /DQJXDJH 64/.

. Paquete que permite incorporar elementos gráficos en las aplicaciones. 6XEFODVH... Es no de los componentes que están incluidos en las Java Fundation Classes. 6XSHUFODVH.Un "proceso ligero" que puede ser arrancado y utilizado más rápidamente que por un IRUN o VSDZQ 9pDVH también: IRUN VSDZQ \ 3URFHVR Página 186 de 189 . 7KUHDG.Clase descendiente de otra clase de la que hereda métodos y variables.Clase de la cual heredan sus métodos y variables otras clases denominadas subclases. Aparece en la versión 1. de una manera más potente que con el AWT.2 del JDK. 6ZLQJ. o JFC...Lenguaje para realizar consultas a Bases de Datos relacionales.

Los tipos primitivos incluyen caracteres. Octubre de 1999 7LHPSR GH YLGD... Versión 2. un tipo de dato que no es un objeto. esto es. enteros. en lugar de los 8 que soportaba ASCII. 7LSR SULPLWLYR.Unified Modeling Language. el número de líneas entre la primera y la última referencia a la variable.Conjunto de caracteres de 16 bits.. número de coma flotante y booleanos. 8QLFRGH. 8QLILHG 0RGHOLQJ /DQJXDJH 80/.En Java.Guía de iniciación al lenguaje Java.0. Así se pueden representar la mayor parte de los lenguajes del mundo. 80/..El número de líneas sobre las que una variable es activa.

.. James Rumbaugh. Página 187 de 189 . 9HFWRU. e Ivar Jacobson.Notación estándar de facto utilizada en el análisis y diseño orientado a objetos.Rutinas en la máquina virtual de Java. basado en el trabajo de Grady Booch. que aseguran que las instrucciones en el archivo de clase no violan ciertas restricciones de seguridad. 9HULILFDGRU GH FyGLJR GH E\WH.Estructura de datos que coloca un tipo de datos en celdas continuas...

0DQXDO GH -DYD . >6DQ] @ -DYLHU 6DQ] $ODPLOOR. (.HQ $UQROG \ -DPHV *RVOLQJ $GGLVRQ:HVOH\'RPR "(O OHQJXDMH GH 3URJUDPDFLyQ -DYD´. ('RFXPHQWDFLyQ GH OD $3. >YDQ +RII HW DO @ $UWKXU YDQ +RII 6DPL 6KDLRL \ 2UFD 6WDUEXFN. 1996.com.PD] $OIRQVR %UD]iOH] $OEHUWR /DU]DEDO -HV~V &DOOHMD \ -RQ *DUFtD. www. Vision 2000 CCS Package and Application Team. >*DUFtD HW DO @ -DYLHU *DUFLi GH -DOyQ -RVp . 1997. 216 páginas. >6XQ @ 6XQ 0LFURV\VWHPV . (7XWRULDO FRPSOHWR HQ .QJOpV HQ IRUPDWR 3')). 140 páginas. 1997.JQDFLR 5RMR )UDLOH. (&RPHQWDQ OD WHRUtD GH OD SURJUDPDFLyQ RULHQWDFLyQ DO REMHWR +DQ VLGR UHVXPLGRV SDUD GDU XQD YLVLyQ GH OD SURJUDPDFLyQ RULHQWDGD D REMHWR HQ HO DSDUWDGR . 395 páginas.Ï1 & >$UQROG \ *RVOLQJ @ . "&RPSDUDWLYD GH KHUUDPLHQWDV -DYD". Mc.QJHQLHUtD 7pFQLFD HQ . $SUHQGD -DYD FRPR VL HVWXYLHUD HQ SULPHUR . En cada reseña bibliográfica se indican el número de páginas que tiene. Octubre de 1999 %. 1997. >1DXJKWRQ @ 3DWULFN 1DXJKWRQ. Artículo de la revista Solo Programadores nº55. "+DQGV RQ -DYD 6HPLQDU".JQDFLR 5RGUtJXH] . >5RMR @ . (0X\ EiVLFR HVFULWR SRU HO GHVDUUROODGRU GHO OHQJXDMH). "1RYHGDGHV \ FDPELRV FRQ -DYD ". Versión 2.QF "-'. Marzo 1999. (&RPSDUD  . 334 páginas.). Tower. Universidad de Navarra.xLJR 0LQJR $LWRU . Octubre 1998. Addison-Weslet.2*5$)Ë$ Se ha dividido este apartado en diversos puntos. "&RGLQJ 6WDQGDUGV IRU & & DQG -DYD".QIRUPiWLFD GH *HVWLyQ". (6LQ GXGD PX\ LQWHUHVDQWH VREUH WRGR SRU VX DFWXDOLGDG DO WUDWDU FRQ -DYD  \ SRU VX H[WHQVLyQ DO WUDWDU WRGDV ODV ELEOLRWHFDV GH -DYD). 1999. 675 páginas. 1999. >-RKQVRQ @ -HII -RKQVRQ. (%XHQ UHVXPHQ GH ORV FDPELRV TXH KDQ VXUJLGR HQ HO -'. Tower. Wesley Iberoamericana.sun.%/. >*DUFtD @ )UDQFLVFR -RVp *DUFtD 3HxDOYR "$SXQWHV GH WHRUtD GH OD DVLJQDWXUD 3URJUDPDFLyQ $YDQ]DGD GHO WHUFHU FXUVR GH . GH -DYD GHO -'.). intentando explicar qué referencias bibliográficas han sido utilizadas en mayor o menor medida para realizar este tutorial. 1997. Presindent MindView Inc. $ %. Prentice Hall. y un comentario personal indicando su utilidad para una mayor profundización en Java. ). Universidad de Burgos. 14 páginas.Guía de iniciación al lenguaje Java. 7RGR OR TXH KDFH IDOWD VDEHU SDUD FUHDU DSSOHWV FRQ PXFKRV HMHPSORV (Q LQJOpV. Graw Hill 1996. >(FNHO @ %UXFH (FNHO.0. (7XWRULDO PX\ EiVLFR HQ HO TXH VH WUDWD OD SRWHQFLD GH -DYD SHUR VLQ SURIXQGL]DU HQ QLQJ~Q WHPD HQ SDUWLFXODU).  'RFXPHQWDWLRQ .'(V -DYD). 577 páginas. 1996.2*5$)Ë$ &2168/7$'$ 3$5$ /$ $&78$/ 9(56. (CRQVHMRV SDUD HO IRUPDWR GH ORV IXHQWHV -DYD & \ &).QWURGXFH WRGRV ORV DVSHFWRV GH OD SURJUDPDFLyQ EiVLFD HQ -DYD). >0RUJDQ @ 0LNH 0RUJDQ "'HVFXEUH -DYD ". Artículo de la revista Solo Programadores nº49. +RRNHG RQ -DYD .%/.

. & & & & & & & & & & Página 188 de 189 .

1997.21$/ 2 &. >&XHQFD @ 3HGUR 0DQXHO &XHQFD -LPpQH] "3URJUDPDFLyQ HQ -DYD".2*5$)Ë$ $'.21(6 '( . 1997. Versión 2.COM Página 189 de 189 . "0RGHODGR \ 'LVHxR 2ULHQWDGRV D 2EMHWRV 0HWRGRORJtD 207". Anaya Multimedia.2*5$)Ë$ $'.Ï1  & >&RUWpV HW DO@ -RVp /XLV &RUWpV 1XULD *RQ]iOH] 9LUJLQLD 3pUH] 3DTXL 9LOOHQD \ $QD 5RVD )UHLUH.QWHUQHW”.PSUHVFLQGLEOH GH -DYD". Anaya multimedia.%/. & & & & & ' '.  VH UHILHUH). >)URXIH @ $JXVWtQ )URXIH.fie. >5DPEDXJK HW DO @ - 5DPEDXJK - 0 %ODKD : 3UHPHUODQL ) (GG\ \ : /RUHQVHQ.21$/ 48( 6( 87. 1998.Guía de iniciación al lenguaje Java. >5LIIOHW @ -HDQ0DULH 5LIIOHW "&RPXQLFDFLRQHV HQ 81. 2º reimpresión. Ra-Ma.=Ï (1 /$ 9(56. "$QiOLVLV \ GLVHxR GHWDOODGR GH $SOLFDFLRQHV LQIRUPiWLFDV GH JHVWLyQ". 1997.rational. & & & & %. "7KH 8QLILHG 0RGHOLQJ /DQJXDJH 'RFXPHQWDWLRQ 6HW ". >5DWLRQDO @ 5DWLRQDO 6RIWZDUH &RUSRUDWLRQ. cuya dirección es: javanews@US. "/D ELEOLD GH -DYD".com. 1998.0.us.%/.es/info/internet/JAVA/. Septiembre de 1997. Octubre de 1999 & >=ROOL @ $QGUHZ =ROOL.&. "0DQXDO . McGraw Hill. % %. >/DODQL @ 6XOHLPDQ 6DP /DODQL. (&RPSOHWR HQ OR D TXH ELEOLRWHFDV GHO -'. Ediciones McGraw Hill.Ï1 & >3LDWWLQL HW DO @ 0DULR * 3LDWWLQL -RVp $ &DOYR0DQ]DQR -RDTXtQ &HUYHUD \ /XLV )HUQiQGH].QWHUQHW . 1996. 1996.7$'$ (1 /$ $&78$/ 9(56. "-DYD HO OHQJXDMH GH SURJUDPDFLyQ GH . 814 páginas.. www. “7XWRULDO GH -DYD”. Prentice Hall. Facultad de Informática de Sevilla. Data Becker 1996.&. Ediciones Anaya Multimedia. Ediciones Anaya Multimedia. "-DYD ELEOLRWHFD GHO SURJUDPDGRU"./. >)UDPLxiQ @ -RVp 0DQXHO )UDPLxiQ 7RUUHV. >&XHQFD @ 3HGUR 0DQXHO &XHQFD -LPpQH] “3URJUDPDFLyQ HQ -DYD SDUD . http://www. 1997.".17(5e6 Se recomienda suscribirse a la lista de correo de Sun sobre Java.IBM.5(&&. 1997.

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->