Lenguaje de programacion java pre

El lenguaje de Programación Java™
Java y todas las marcas basadas en Java son marcas registradas
propiedad de Sun Microsystems, Inc. En los Estados Unidos y en
otros paises. El contenido de este libro: “El lenguaje de
programación Javatm” es independiente de Sun Microsystems,
Inc.

MARCAS REGISTRADAS

Sun, el logotipo Sun, Sun Microsystems, JavaSoft, JavaBeans, JDK, Java, HotJava, HotJava Views,
Visual Java, Solaris, NEO, Joe, Netra, NFS, ONC, ONC+, OpenWindows, PC-NFS, SNM, SunNet
Manager, Solaris sunburst design, Solstice, SunCore, SolarNet, SunWeb, Sun Workstation, The
Network Is The Computer, ToolTalk, Ultra, Ultracomputing, Ultraserver, Where The Network Is
Going, Sun WorkShop, XView, Java WorkShop, el logo Java Coffee Cup, y Visual Java son marcas
registradas de Sun Microsystems, Inc.

UNIX es una marca registrada en los Estados Unidos y otros países, empleado con licencia de
X/Open Company, Ltd. OPEN LOOK® es una marca registrada de Novell, Inc.

Los interfaces gráficos OPEN LOOK® y Sun(TM) GUI fueron desarrollados por Sun
Microsystems, Inc. Para sus usuarios y licenciatarios. Sun reconoce el esfuerzo pionero de Xerox en
la investigación y el desarrollo del concepto de interface de unsuario gráfica. Sun mantiene una
licencia no exclusiva de Xerox sobre el interface gráfico de usuario de Xerox, que permite a Sun
implementar GUIs OPEN LOOK.

X Window System es una marca registrada del X Consortium, Inc.

OpenStep es una marca propiedad de NeXT.

1

PREÁMBULO........................................................................................................................9
1. INTRODUCCIÓN..........................................................................................................11
1.1 HISTORIA DEL LENGUAJE....................................................................................... 11
1.2 ¿QUÉ ES JAVA™?.................................................................................................... 12
1.3 ¿QUÉ LO HACE DISTINTO DE LOS DEMÁS LENGUAJES?....................................... 12
1.3.1 ¿Qué se puede programar con Java? .....................................................13
1.3.2 ¿Es fácil de aprender?...............................................................................13
1.3.3 Características del lenguaje.....................................................................14
1.4 LA M ÁQUINA VIRTUAL JAVA (JVM). .................................................................. 16
1.5 JAVASCRIPT............................................................................................................. 17
1.6 EL ENTORNO DE DESARROLLO JDK...................................................................... 18
1.6.1 ¿Dónde conseguirlo? .................................................................................18
1.6.2 Estructura de directorios. .........................................................................19
1.6.3 Configuración. ............................................................................................19
1.7 PROGRAMACIÓN ORIENTADA A OBJETOS............................................................. 20
1.7.1 ¿Qué es un objeto?.....................................................................................20
1.7.2 Clases y objetos...........................................................................................21
1.7.3 Propiedades que debe cumplir un lenguaje para ser considerado
Orientado a Objetos...................................................................................23
1.8 CUESTIONES......................................................................................................... 27
2. VISIÓN GENERAL Y ELEMENTOS BÁSICOS DEL LENGUAJE.............29
2.1 HOLA, MUNDO......................................................................................................... 30
2.2 COMENTARIOS......................................................................................................... 33
2.3 TIPOS DE DATOS....................................................................................................... 34
2.4 TIPOS DE DATOS SIMPLES....................................................................................... 35
2.5 TIPOS DE DATOS REFERENCIALES. ........................................................................ 36
2.6 IDENTIFICADORES. .................................................................................................. 37
2.7 DECLARACIÓN DE VARIABLES............................................................................... 39
2.8 ÁMBITO DE UNA VARIABLE. .................................................................................. 40
2.8.1 Variables locales. .......................................................................................40
2.8.2 Atributos.......................................................................................................43
2.8.3 Parámetros de un método. ........................................................................44
2.9 OPERADORES. .......................................................................................................... 46
2.9.1 Operadores aritméticos:............................................................................47
2.9.2 Operadores relacionales:..........................................................................49
2.9.3 Operadores lógicos:...................................................................................50
2.9.4 Operadores de bits:....................................................................................51
2.9.5 Operadores de asignación:.......................................................................53
2.9.6 Precedencia de operadores en Java: ......................................................54
2.10 CONSTANTES............................................................................................................ 55
2.11 VALORES LITERALES. ............................................................................................. 55
2.12 ESTRUCTURAS DE CONTROL.................................................................................. 60
2.12.1Estructuras alternativas. ...........................................................................60

2

2.12.2Bucles............................................................................................................66
2.12.3Saltos.............................................................................................................70
2.13 VECTORES. ............................................................................................................... 72
2.14 CUESTIONES......................................................................................................... 76
3. LAS CLASES EN JAVA. .............................................................................................77
3.1 DECLARACIÓN DE CLASE. ...................................................................................... 78
3.1.1 Declaración de la superclase (herencia). ..............................................79
3.1.2 Lista de interfaces.......................................................................................79
3.1.3 Modificadores de clase..............................................................................80
3.2 EL CUERPO DE LA CLASE........................................................................................ 83
3.3 DECLARACIÓN DE ATRIBUTOS............................................................................... 84
3.3.1 Atributos static......................................................................................85
3.3.2 Atributos final.........................................................................................86
3.3.3 Atributos transient..............................................................................87
3.3.4 Atributos volatile.................................................................................88
3.3.5 Modificadores de ámbito de atributos. ...................................................89
3.4 M ÉTODOS ................................................................................................................. 94
3.4.1 Declaración de método..............................................................................94
3.4.2 Cuerpo del método. ................................................................................. 102
3.4.3 Constructores. .......................................................................................... 106
3.4.4 Destructores.............................................................................................. 110
3.5 STRINGS...............................................................................................................110
3.5.1 La clase String. ........................................................................................ 111
3.5.2 La clase StringBuffer............................................................................... 114
3.6 LA LÍNEA DE COMANDOS......................................................................................115
3.7 INTERFACES. ..........................................................................................................116
3.7.1 Declaración de interface........................................................................ 117
3.7.2 Cuerpo del interface................................................................................ 118
3.8 LOS PAQUETES.......................................................................................................120
3.8.1 Declaración de paquetes........................................................................ 120
3.8.2 Cómo hacer uso de los paquetes existentes. ....................................... 122
3.8.3 Paquetes pertenecientes al Java. .......................................................... 123
3.9 EJEMPLO COMPLETO.............................................................................................125
3.9.1 Generar números aleatorios.................................................................. 127
3.9.2 Creación de un bombo............................................................................ 129
3.9.3 La clase Resultado. ................................................................................. 131
3.9.4 El programa principal............................................................................ 132
3.9.5 Modificando la clase Resultado............................................................ 133
3.10 CUESTIONES.......................................................................................................136
4. TRATAMIENTO DE EXCEPCIONES................................................................ 137
4.1 LANZAMIENTO DE EXCEPCIONES (THROW). ......................................................138
4.2 TRATAMIENTO DE EXCEPCIONES. .......................................................................139
4.2.1 Manejador de excepciones..................................................................... 139
4.3 JERARQUÍA DE EXCEPCIONES...............................................................................142
4.4 VENTAJAS DEL TRATAMIENTO DE EXCEPCIONES..............................................151

3

4.4.1 Separación del código “útil” del tratamiento de errores................. 151
4.4.2 Propagación de errores a través de la pila de métodos. .................. 153
4.4.3 Agrupación y diferenciación de errores.............................................. 155
4.4.4 Claridad del código y obligación del tratamiento de errores.......... 156
4.5 CUESTIONES.......................................................................................................157
5. LA ENTRADA/SALIDA EN JAVA....................................................................... 159
5.1 STREAMS. ...............................................................................................................159
5.2 JERARQUÍA DE CLASES EN EL PAQUETE JAVA.IO. .............................................159
5.2.1 El paquete java.io en el JDK 1.02. ....................................................... 160
5.2.2 El paquete java.io en el JDK 1.1........................................................... 161
5.3 CLASES IMPORTANTES PARA LA ENTRADA/SALIDA ESTÁNDAR. ...................164
5.3.1 La clase InputStream............................................................................... 164
5.3.2 La clase OutputStream............................................................................ 165
5.3.3 La clase PrintStream............................................................................... 166
5.4 ENTRADA/SALIDA ESTÁNDAR.............................................................................168
5.5 STREAMS DE CARACTERES...................................................................................169
5.5.1 La clase Reader........................................................................................ 170
5.5.2 La clase Writer. ........................................................................................ 171
5.5.3 La clase BufferdReader. ......................................................................... 171
5.5.4 La clase PrintWriter................................................................................ 172
5.6 ENTRADA POR TECLADO Y SALIDA POR PANTALLA. ........................................173
5.7 FICHEROS................................................................................................................175
5.7.1 La clase File. ............................................................................................ 175
5.7.2 La clase FileDescriptor.......................................................................... 177
5.7.3 Acceso a ficheros secuenciales. ............................................................ 178
5.7.4 La clase RandomAccessFile. ................................................................. 183
5.7.5 Acceso a ficheros aleatorios.................................................................. 185
5.8 SERIALIZACIÓN DE OBJETOS................................................................................187
5.8.1 Esquema de funcionamiento de la serialización................................ 188
5.8.2 Personalización en la serialización. .................................................... 193
5.9 CUESTIONES.......................................................................................................197
6. THREADS..................................................................................................................... 199
6.1 ¿QUÉ SON LOS THREADS?.....................................................................................199
6.1.1 Un ejemplo, mejor que mil palabras.................................................... 199
6.1.2 Otro ejemplo............................................................................................. 201
6.1.3 Y otro ejemplo más. ................................................................................. 202
6.2 ESTADO DE UN THREAD. ......................................................................................203
6.3 CREACIÓN DE THREADS........................................................................................204
6.4 OPERACIONES SOBRE THREADS...........................................................................207
6.4.1 currentThread(). ...................................................................................... 207
6.4.2 isAlive(). .................................................................................................... 207
6.4.3 sleep(). ....................................................................................................... 208
6.4.4 suspend()................................................................................................... 209
6.4.5 wait().......................................................................................................... 209
6.4.6 yield()......................................................................................................... 209

4

6.4.7 join(). ......................................................................................................... 211
6.5 THREADS Y SINCRONISMO. ..................................................................................212
6.5.1 El paradigma productor/consumidor................................................... 213
6.5.2 Sección crítica.......................................................................................... 214
6.5.3 Monitores.................................................................................................. 217
6.6 PRIORIDAD DE UN THREAD..................................................................................224
6.7 THREADS DAEMON...............................................................................................226
6.8 GRUPOS DE THREADS............................................................................................227
6.8.1 Creación de grupos de threads. ............................................................ 227
6.8.2 Operaciones sobre threads agrupados................................................ 229
6.9 CUESTIONES.......................................................................................................233
7. COMUNICACIONES TCP/IP ................................................................................ 235
7.1 INTRODUCCIÓN......................................................................................................235
7.2 ARQUITECTURA CLIENTE / SERVIDOR. ..............................................................236
7.3 LA ABSTRACCIÓN SOCKET...................................................................................237
7.4 SERVICIO SIN CONEXIÓN (DATAGRAM SOCKET)..............................................239
7.4.1 Creación de un DatagramSocket.......................................................... 239
7.5 SERVICIO ORIENTADO A CONEXIÓN (STREAM SOCKET)..................................242
7.5.1 Operaciones en el servidor.................................................................... 243
7.5.2 Espera de conexiones de clientes.......................................................... 243
7.5.3 Operaciones en el cliente....................................................................... 244
7.6 CUESTIONES.......................................................................................................251
A. LAS HERRAMIENTAS JAVA............................................................................... 253
A.1 JAVAC (COMPILADOR). .........................................................................................253
A.1.1 Opciones.................................................................................................... 253
A.2 JAVA (INTÉRPRETE)...............................................................................................255
A.2.1 Opciones.................................................................................................... 255
A.3 JAVAW (INTÉRPRETE). ..........................................................................................258
A.4 JDB (DEPURADOR).................................................................................................259
A.4.1 Comandos básicos................................................................................... 260
A.5 JAVAH (GENERADOR DE CABECERAS C)............................................................261
A.6 JAVAP (DESENSAMBLADOR)................................................................................262
A.6.1 Opciones.................................................................................................... 263
A.7 JAVADOC (GENERADOR DE DOCUMENTACIÓN). ...............................................265
A.7.1 Etiquetas de clase o interface................................................................ 266
A.7.2 Etiquetas de atributo............................................................................... 269
A.7.3 Etiquetas de constructor o método....................................................... 269
A.7.4 Opciones.................................................................................................... 269
B. CONVERSIÓN DE TIPOS....................................................................................... 273
B.1 CONVERSIÓN POR AMPLIACIÓN DE TIPOS DE DATOS SIMPLES. .......................273
B.2 CONVERSIÓN POR REDUCCIÓN DE TIPOS DE DATOS SIMPLES..........................275
B.3 CONVERSIÓN POR AMPLIACIÓN DE TIPOS DE DATOS REFERENCIALES...........277
B.4 CONVERSIÓN POR REDUCCIÓN DE TIPOS DE DATOS REFERENCIALES. ...........278
B.5 CONVERSIONES DE TIPOS NO PERMITIDAS.........................................................281

5

C. LAS CLASES STRING Y STRINGBUFFER..................................................... 283
C.1 LA CLASE STRING..................................................................................................283
C.1.1 Constructores de la clase String........................................................... 283
C.1.2 Métodos de la clase String..................................................................... 284
C.2 LA CLASE STRINGBUFFER....................................................................................289
C.2.1 Constructores de la clase StringBuffer. ............................................... 289
C.2.2 Métodos de la clase StringBuffer. ......................................................... 289
D. CLASES ANIDADAS................................................................................................. 293
D.1 UTILIDAD DE LAS CLASES ANIDADAS.................................................................294
D.2 CLASES ANIDADAS COMO MIEMBROS DE OTRAS CLASES. ...............................295
D.3 CLASES INTERIORES A UN BLOQUE O LOCALES A UN MÉTODO.......................299
D.4 CLASES ANÓNIMAS. ..............................................................................................302
E. CLASES SOBRE STREAMS Y FICHEROS...................................................... 305
E.1 LA CLASE INPUTSTREAM .....................................................................................305
E.1.1 Constructor............................................................................................... 305
E.1.2 Métodos..................................................................................................... 305
E.2 LA CLASE OUTPUTSTREAM .................................................................................308
E.2.1 Constructor............................................................................................... 308
E.2.2 Métodos..................................................................................................... 309
E.3 LA CLASE PRINTSTREAM.....................................................................................310
E.3.1 Constructores. .......................................................................................... 310
E.3.2 Métodos..................................................................................................... 311
E.4 LA CLASE READER................................................................................................312
E.4.1 Atributo...................................................................................................... 312
E.4.2 Constructores. .......................................................................................... 313
E.4.3 Métodos..................................................................................................... 313
E.5 LA CLASE WRITER. ...............................................................................................316
E.5.1 Atributo...................................................................................................... 316
E.5.2 Constructores. .......................................................................................... 316
E.5.3 Métodos..................................................................................................... 316
E.6 LA CLASE BUFFERDREADER. ..............................................................................318
E.6.1 Constructores. .......................................................................................... 318
E.6.2 Métodos..................................................................................................... 318
E.6.3 La clase PrintWriter................................................................................ 320
E.7 LA CLASE FILE.......................................................................................................323
E.8 LA CLASE RANDOMACCESSFILE. .......................................................................328
E.8.1 Constructores. .......................................................................................... 328
E.8.2 Métodos..................................................................................................... 328
F. EL FORMATO DE STRINGS UTF-8................................................................... 335
F.1 CARACTERES DE UN SOLO BYTE. ........................................................................335
F.2 CARACTERES DE DOS BYTES................................................................................335
F.3 CARACTERES DE TRES BYTES. .............................................................................336
G. CLASES EN JAVA.NET........................................................................................... 337
G.1 CLASS SOCKET ......................................................................................................337

6

G.1.1 CONSTRUCTORES: ............................................................................... 338
G.1.2 MÉTODOS................................................................................................ 340
G.2 CLASS SERVERSOCKET ........................................................................................342
G.2.1 CONSTRUCTORES: ............................................................................... 343
G.2.2 MÉTODOS................................................................................................ 344
G.3 CLASS DATAGRAMSOCKET .................................................................................346
G.3.1 CONSTRUCTORES................................................................................. 347
G.3.2 MÉTODOS................................................................................................ 347
G.4 CLASS INET ADDRESS............................................................................................349
G.4.1 MÉTODOS................................................................................................ 349
G.5 CLASS DATAGRAMPACKET.................................................................................352
G.5.1 CONSTRUCTORES................................................................................. 352
G.5.2 MÉTODOS................................................................................................ 353

7

A nuestras familias, por
permitirnos robarles el tiempo
que hemos dedicado a este
libro. Muy especialmente a
nuestras esposas Mª Carmen y
Susana.

Sin su apoyo incondicional y su
paciencia este libro no habría
sido posible.

8

PREÁMBULO.

El presente texto está escrito de forma que pueda utilizarse tanto para aprender el
lenguaje de programación Java, como para la consulta de atributos y métodos
pertenecientes a clases del JDK1 1.1. Si bien se encontrará una descripción mucho
más pormenorizada y actualizada en la documentación on-line que acompaña a
este software.

Este libro no está orientado para iniciarse en la programación de applets con los
que dotar de animación o interacción a páginas web. Por el contrario, el principal
objetivo de este texto es presentar los fundamentos de la programación en el
lenguaje Java, con el fin de construir cualquier tipo de aplicación (la construcción
de applets y los aspectos gráficos se abordarán en un texto posterior “El lenguaje
de programación Java II”).

En la actualidad existen diferentes paquetes para el desarrollo de aplicaciones en
Java con herramientas más visuales que las que proporciona el JDK (que no son
visuales en absoluto), sin embargo sigue siendo Sun Microsystems la empresa que
controla la especificación de este lenguaje. La misma que desarrolla y distribuye
(de momento) gratuitamente este paquete. Por este motivo, en este volumen se
utilizarán estas herramientas algo “espartanas” pero indudablemente más
avanzadas que otros productos con un look más moderno pero con un inevitable
atraso en cuanto a las últimas modificaciones en el lenguaje y sus librerías.

Queremos insistir en que Java no es un lenguaje necesariamente ligado a Internet.
Las aplicaciones en Java, al igual que las de otros lenguajes, pueden ser de
cualquier naturaleza, ejecutarse sin problemas en ordenadores sin conexión a
Internet y realizar todo tipo de tareas, desde cálculo científico hasta juegos,
pasando por aplicaciones de negocios y oficina.

Lo que diferencia a Java de otros lenguajes de programación es su concepción de
partida, en la que se pretende crear un lenguaje “todo-terreno” que se pueda
utilizar para programar en todo tipo de sistemas operativos y procesadores.

Los autores deseamos que el lector disfrute con la lectura de este libro, y
realizando sus ejemplos, tanto como nosotros lo hemos hecho con su redacción,

1
JDK son las siglas de Java Developers Kit. Es decir, conjunto de herramientas para desarrollar (aplicaciones)
en Java.

9

en la que inevitablemente hemos omitido algunos aspectos que nos hubiera
gustado contar pero que han quedado en el tintero por motivos de tiempo y
espacio.

Java, como todo nuevo lenguaje, acabará siendo lo que la comunidad de
programadores desee que sea. Si su uso se extiende debido a que se aprecian las
ventajas que aporta, las limitaciones que presenta en estos momentos se irán
reduciendo paulatinamente.

Muchos fabricantes de software están migrando sus aplicaciones a este nuevo
lenguaje. Posiblemente debido a que valoran más las ventajas y,
fundamentalmente la posibilidad de desarrollar una sola aplicación para múltiples
plataformas así como la mayor facilidad que ofrece Java para el mantenimiento
posterior de las aplicaciones

Donde encuentre el símbolo � significa que hay un ejemplo que puede
probarse. Es la forma más fácil de aprender. También es interesante tener iniciada
una sesión con algún navegador y acceder a las API’s de la documentación del
JDK para consulta.

10

1. INTRODUCCIÓN.

1.1 Historia del lenguaje.

El lenguaje Java™ fue creado por Sun Microsystems Inc. en un proceso por
etapas que arranca en 1990, año en el que Sun creó un grupo de trabajo, liderado
por James Gosling, para desarrollar un sistema para controlar electrodomésticos e
incluso PDAs o Asistentes Personales (pequeños ordenadores) que, además,
permitiera la conexión a redes de ordenadores. Se pretendía crear un hardware
polivalente, con un Sistema Operativo eficiente (SunOS) y un lenguaje de
desarrollo denominado Oak (roble), el precursor de Java. El proyecto finalizó en
1992 y resultó un completo fracaso debido al excesivo coste del producto, con
relación a alternativas similares, tras lo cual el grupo se disolvió.

Por entonces aparece Mosaic y la World Wide Web. Después de la disolución
del grupo de trabajo, únicamente quedaba del proyecto el lenguaje Oak. Gracias a
una acertada decisión de distribuir libremente el lenguaje por la Red de Redes y al
auge y la facilidad de acceso a Internet, propiciado por la WWW, el lenguaje se
popularizó y se consiguió que una gran cantidad de programadores lo depurasen y
terminasen de perfilar la forma y usos del mismo. A partir de este momento, el
lenguaje se difunde a una velocidad vertiginosa, añadiéndosele numerosas clases
y funcionalidad para TCP/IP. El nombre del lenguaje tuvo que ser cambiado ya
que existía otro llamado Oak. El nombre “Java” surgió en una de las sesiones de
“brainstorming” celebradas por el equipo de desarrollo del lenguaje. Buscaban un
nombre que evocara la esencia de la tecnología (viveza, animación, rapidez,
interactividad …). Java fue elegido de entre muchísimas propuestas. No es un
acrónimo, sino únicamente algo humeante, caliente y que a muchos
programadores les gusta beber en grandes cantidades: una taza de café (Java en
argot Inglés americano2 ). De esta forma, Sun lanzó las primeras versiones de Java
a principios de 1995.

Desde entonces, Sun ha sabido manejar inteligentemente el éxito obtenido por su
lenguaje, concediéndose licencias a cualquiera sin ningún problema, fomentando

2
Casualmente, la pronunciación en inglés de este término es “yava”, que puede entenderse fuera de contexto
como “¡ya va!”.

11

Introducción.

su uso entre la comunidad informática y extendiendo las especificaciones y
funcionalidad del lenguaje.

1.2 ¿Qué es Java™?

Java es un lenguaje de desarrollo de propósito general, y como tal es
válido para realizar todo tipo de aplicaciones profesionales.

Entonces, ¿es simplemente otro lenguaje más? Definitivamente no. Incluye una
combinación de características que lo hacen único y está siendo adoptado por
multitud de fabricantes como herramienta básica para el desarrollo de
aplicaciones comerciales de gran repercusión.

1.3 ¿Qué lo hace distinto de los demás lenguajes?

Una de las características más importantes es que los programas
“ejecutables”, creados por el compilador de Java, son independientes
de la arquitectura. Se ejecutan indistintamente en una gran variedad
de equipos con diferentes microprocesadores y sistemas operativos.

• De momento, es público. Puede conseguirse un JDK (Java Developer's
Kit) o Kit de desarrollo de aplicaciones Java gratis. No se sabe si en un
futuro seguirá siéndolo.

• Permite escribir Applets (pequeños programas que se insertan en una
página HTML) y se ejecutan en el ordenador local.

• Se pueden escribir aplicaciones para intrarredes, aplicaciones
cliente/servidor, aplicaciones distribuidas en redes locales y en
Internet.

• Es fácil de aprender y está bien estructurado.

• Las aplicaciones son fiables. Puede controlarse su seguridad frente al
acceso a recursos del sistema y es capaz de gestionar permisos y
criptografía. También, según Sun, la seguridad frente a virus a través
de redes locales e Internet está garantizada. Aunque al igual que ha

12

Introducción.

ocurrido con otras tecnologías y aplicaciones, se han descubierto, y
posteriormente subsanado, “agujeros” en la seguridad3 de Java.

1.3.1 ¿Qué se puede programar con Java?

Si tenía preconcebida la idea de que con Java sólo se programan applets para
páginas web, está completamente equivocado. Ya que Java es un lenguaje de
propósito general, puede programarse en él cualquier cosa:

• Aplicaciones independientes. Como con cualquier otro lenguaje de
propósito general.

• Applets. Pequeñas aplicaciones que se ejecutan en un documento
HTML, siempre y cuando el navegador soporte Java, como ocurre con
los navegadores HotJava y las últimas versiones de Netscape y el
explorador de Internet de Microsoft.

1.3.2 ¿Es fácil de aprender?

Sí.

Para el colectivo de programadores que conocen la programación orientada a
objetos, el cambio a Java puede ser realmente sencillo. Es un lenguaje bien
estructurado, sin punteros y sin necesidad de tener que controlar la asignación de
memoria a estructuras de datos u objetos.

Para los programadores en C++ también es sencillo el cambio, ya que la sintaxis
es prácticamente la misma que en este lenguaje.

Para todo aquel que no conozca la programación orientada a objetos, este lenguaje
es ideal para aprender todos sus conceptos, ya que en cada paso de su aprendizaje
se va comprobando que las cosas se hacen en la forma natural de hacerlas, sin
sorpresas ni comportamientos extraños de los programas. A medida que se va
aprendiendo, se va fomentando en el programador, y sin esfuerzo, un buen estilo
de programación orientada a objetos. En realidad, no puede ser de otra forma, ya

3
El aspecto de seguridad tiene importancia fundamental en la creación de applets puesto que estos programas
son ejecutados en el navegador de cada usuario es necesario poder garantizarle que su sistema y sus datos están
seguros de posibles virus y/o fisgoneos de terceras personas que podrían utilizar la red como medio para fines
más o menos oscuros.

13

Introducción.

que Java impide “hacer cosas extrañas” y, además, no permite “abandonar” la
programación orientada a objetos, como ocurre con otros lenguajes de
programación. Esto es bastante conveniente, de lo contrario, un programador que
está aprendiendo puede sentir la tentación de “volver” a lo que conoce (la
programación tradicional).

A medida que se van comprobando las ventajas de la programación orientada a
objetos, para aquellos que las desconocen, y la facilidad y naturalidad del
lenguaje Java, éste va atrapando a quien se acerca a él, y después de algún tiempo
trabajando con Java, hay pocos programadores que no lo consideren como “su
favorito”.

1.3.3 Características del lenguaje.

• Es intrínsecamente orientado a objetos.

• Funciona perfectamente en red.

• Aprovecha características de la mayoría de los lenguajes modernos evitando
sus inconvenientes. En particular los del C++.

• Tiene una gran funcionalidad gracias a sus librerías (clases).

• NO tiene punteros manejables por el programador, aunque los maneja interna
y transparentemente.

• El manejo de la memoria no es un problema, la gestiona el propio lenguaje y
no el programador.

• Genera aplicaciones con pocos errores posibles.

• Incorpora Multi-Threading (para permitir la ejecución de tareas concurrentes
dentro de un mismo programa). Esta característica será tratada con
detenimiento en el punto � 6 Threads. En la página 199.

El lenguaje Java puede considerarse como una evolución del C++. La sintaxis es
parecida a la de este lenguaje, por lo que en este libro se hará referencia a dicho
lenguaje frecuentemente. A pesar de que puede considerarse como una evolución
del C++ no acarrea los inconvenientes del mismo, ya que Java fue diseñado
“partiendo de cero”, es decir, no necesitaba ser compatible con versiones
anteriores de ningún lenguaje como ocurre con C++ y C.

14

Introducción.

Gracias a que fue diseñado “partiendo de cero” ha conseguido convertirse en un
lenguaje orientado a objetos puro, limpio y práctico. No permite programar
mediante otra técnica que no sea la programación orientada a objetos (POO en
adelante) y, una vez superado el aprendizaje de la programación orientada a
objetos, es realmente sencillo aprender Java.

¿El lenguaje es Compilado o Interpretado? Ni una cosa ni la otra. Aunque
estrictamente hablando es interpretado, necesita de un proceso previo de
compilación. Una vez “compilado” el programa, se crea un fichero que almacena
lo que se denomina bytecodes o j_code (pseudocódigo prácticamente al nivel de
código máquina). Para ejecutarlo, es necesario un “intérprete”, la JVM (Java
Virtual Machine) máquina virtual Java. De esta forma, es posible compilar el
programa en una estación UNIX y ejecutarlo en otra con Windows95 utilizando la
máquina virtual Java para Windows95. Esta JVM se encarga de leer los bytecodes
y traducirlos a instrucciones ejecutables directamente en un determinado
microprocesador, de una forma bastante eficiente.

Que el programa deba ser
“interpretado” no hace que sea
Editor poco eficiente en cuanto a
velocidad, ya que la
interpretación se hace
prácticamente al nivel de código
máquina. Por ejemplo, es mucho
Programa fuente Programa.java más rápido que cualquier otro
programa interpretado como por
ejemplo Visual Basic, aunque es
Compilación más lento que el mismo
(Javac) programa escrito en C++.

Esta deficiencia en cuanto a la
ByteCode Programa.class velocidad, puede ser aminorada
por los compiladores Just-In-
Time (JIT). Un compilador JIT
Interpretación por transforma los bytecodes de un
programa o un applet en código
la JVM (Java) nativo de la plataforma donde se
ejecuta, por lo que es más rápido.
Código máquina Suelen ser incorporados por los
navegadores, como Netscape o
Internet Explorer.

15

Introducción.

El lenguaje Java es robusto. Las aplicaciones creadas en este lenguaje son
susceptibles de contener pocos errores, principalmente porque la gestión de
memoria y punteros es realizada por el propio lenguaje y no por el programador.
Bien es sabido que la mayoría de los errores en las aplicaciones vienen
producidos por fallos en la gestión de punteros o la asignación y liberación de
memoria. Además, el lenguaje contiene estructuras para la detección de
excepciones (errores de ejecución previstos) y permite obligar al programador a
escribir código fiable mediante la declaración de excepciones posibles para una
determinada clase reutilizable.

1.4 La Máquina Virtual Java (JVM).

La máquina virtual Java es la idea revolucionaria4 del lenguaje. Es la entidad que
proporciona la independencia de plataforma para los programas Java
“compilados” en byte-code.

Programa fuente F.java

Compilación
(Javac)
Clase1.class
ByteCode Clase2.class
ClaseN.class

JVM para la JVM para la JVM para la
máquina 1 máquina 2 máquina 3

Código máquina Código máquina Código máquina
1 2 3

4
Bueno, no completamente revolucionario, otros sistemas en el pasado, como por ejemplo el Pascal UCSD
compilaban a un código intermedio (p-code) que luego era interpretado al ejecutar el programa. No obstante, esta
estrategia no es la habitual en la mayoría de lenguajes, al menos no lo ha sido hasta ahora.

16

Introducción.

Un mismo programa fuente compilado en distintas plataformas o sistemas
operativos, genera el mismo fichero en byte-code. Esto es lógico, ya que se
supone que el compilador de Java traduce el fichero fuente a código ejecutable
por una máquina que únicamente existe en forma virtual (aunque se trabaja en la
construcción de microprocesadores que ejecuten directamente el byte-code).

Evidentemente, si un mismo programa en byte-code puede ser ejecutado en
distintas plataformas es porque existe un traductor de ese byte-code a código
nativo de la máquina sobre la que se ejecuta. Esta tarea es realizada por la JVM.
Existe una versión distinta de esta JVM para cada plataforma. Esta JVM se carga
en memoria y va traduciendo “al vuelo”, los byte-codes a código máquina. La
JVM no ocupa mucho espacio en memoria, piénsese que fue diseñada para poder
ejecutarse sobre pequeños electrodomésticos como teléfonos, televisores, etc.

1.5 JavaScript.

Atención: No hay que confundir Java con JavaScript.

JavaScript es una variación del lenguaje Java. Desarrollado por Netscape y Sun,
fue diseñado para simplificar la creación de contenidos interactivos en páginas
web sin necesidad de tener que programar applets en Java. En lugar de ello se
utilizan técnicas más sencillas mediante el lenguaje JavaScript que es más
flexible, aunque mucho menos potente.

El lenguaje JavaScript es totalmente interpretado por el navegador. El código
fuente se incluye como parte de la página web en HTML y es el navegador el
encargado de “interpretar” el código fuente.

¿No podría hacerse en Java? Sí, pero no de forma tan sencilla como con
JavaScript. Este lenguaje fue pensado para acercar Java a programadores
inexpertos y creadores de contenidos HTML sin conocimientos avanzados de
programación.

Diferencias entre Java y JavaScript:

• Java es compilado, mientras que JavaScript es totalmente interpretado.

• Java es orientado a objetos. JavaScript utiliza objetos, pero no permite
la programación orientada a objetos.

17

Introducción.

• En JavaScript no es necesario declarar las variables y en Java sí.

• En JavaScript, las comprobaciones de validez de referencias a objetos
se realizan en tiempo de ejecución, mientras que en Java se realiza en
tiempo de compilación.

• JavaScript tiene un número limitado de tipos de datos y clases.

• Los applets Java se transmiten como código aparte de la página Web.
En JavaScript, los applets se transmiten conjuntamente con la página
web (embebidos en ella).

1.6 El entorno de desarrollo JDK.

La herramienta básica para empezar a desarrollar aplicaciones o applets en Java
es el JDK (Java Developer’s Kit) o Kit de Desarrollo Java, que consiste,
básicamente, en un compilador y un intérprete (JVM) para la línea de comandos.
No dispone de un entorno de desarrollo integrado (IDE), pero es suficiente para
aprender el lenguaje y desarrollar pequeñas aplicaciones.

1.6.1 ¿Dónde conseguirlo?

El Kit de desarrollo puede obtenerse en las direcciones siguientes:

• http://www.sun.com
• http://www.javasoft.com

El entorno para Windows95/NT está formado por un fichero ejecutable que
realiza la instalación, creando toda la estructura de directorios. El kit contiene
básicamente:

• El compilador: javac.exe
• El depurador: jdb.exe
• El intérprete: java.exe y javaw.exe
• El visualizador de applets: appletviewer.exe
• El generador de documentación: javadoc.exe

18

Lenguaje de programacion java pre

Más contenido relacionado

La actualidad más candente (9)

Destacado (20)

Similar a Lenguaje de programacion java pre (20)

Más de jtk1 (20)

Lenguaje de programacion java pre