¡Descarga Iniciacion a Lenguaje Java y más Guías, Proyectos, Investigaciones en PDF de Programación Java solo en Docsity!
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.7.3 Propiedades que debe cumplir un lenguaje para ser considerado
- PREÁMBULO........................................................................................................................
- INTRODUCCIÓN..........................................................................................................
- 1.1 HISTORIA DEL LENGUAJE.......................................................................................
- 1.2 ¿QUÉ ES JAVA™?....................................................................................................
- 1.3 ¿QUÉ LO HACE DISTINTO DE LOS DEMÁS LENGUAJES?.......................................
- 1.3.1 ¿Qué se puede programar con Java? .....................................................
- 1.3.2 ¿Es fácil de aprender?...............................................................................
- 1.3.3 Características del lenguaje.....................................................................
- 1.4 LA MÁQUINA VIRTUAL JAVA (JVM).
- 1.5 JAVASCRIPT.............................................................................................................
- 1.6 EL ENTORNO DE DESARROLLO JDK......................................................................
- 1.6.1 ¿Dónde conseguirlo?.................................................................................
- 1.6.2 Estructura de directorios. .........................................................................
- 1.6.3 Configuración. ............................................................................................
- 1.7 PROGRAMACIÓN ORIENTADA A OBJETOS.............................................................
- 1.7.1 ¿Qué es un objeto?.....................................................................................
- 1.7.2 Clases y objetos...........................................................................................
- Orientado a Objetos...................................................................................
- 1.8 CUESTIONES.........................................................................................................
- VISIÓN GENERAL Y ELEMENTOS BÁSICOS DEL LENGUAJE.............
- 2.1 HOLA, MUNDO.........................................................................................................
- 2.2 COMENTARIOS.........................................................................................................
- 2.3 TIPOS DE DATOS.......................................................................................................
- 2.4 TIPOS DE DATOS SIMPLES.......................................................................................
- 2.5 TIPOS DE DATOS REFERENCIALES.
- 2.6 IDENTIFICADORES.
- 2.7 DECLARACIÓN DE VARIABLES...............................................................................
- 2.8 ÁMBITO DE UNA VARIABLE.
- 2.8.1 Variables locales. .......................................................................................
- 2.8.2 Atributos.......................................................................................................
- 2.8.3 Parámetros de un método. ........................................................................
- 2.9 OPERADORES.
- 2.9.1 Operadores aritméticos:............................................................................
- 2.9.2 Operadores relacionales:..........................................................................
- 2.9.3 Operadores lógicos:...................................................................................
- 2.9.4 Operadores de bits:....................................................................................
- 2.9.5 Operadores de asignación:.......................................................................
- 2.9.6 Precedencia de operadores en Java: ......................................................
- 2.10 CONSTANTES............................................................................................................
- 2.11 VALORES LITERALES.
- 2.12 ESTRUCTURAS DE CONTROL..................................................................................
- 2.12.1Estructuras alternativas. ...........................................................................
- 2.12.2Bucles............................................................................................................
- 2.12.3Saltos.............................................................................................................
- 2.13 VECTORES.
- 2.14 CUESTIONES.........................................................................................................
- LAS CLASES EN JAVA. .............................................................................................
- 3.1 DECLARACIÓN DE CLASE.
- 3.1.1 Declaración de la superclase (herencia). ..............................................
- 3.1.2 Lista de interfaces.......................................................................................
- 3.1.3 Modificadores de clase..............................................................................
- 3.2 EL CUERPO DE LA CLASE........................................................................................
- 3.3 DECLARACIÓN DE ATRIBUTOS...............................................................................
- 3.3.1 Atributos static......................................................................................
- 3.3.2 Atributos final.........................................................................................
- 3.3.3 Atributos transient..............................................................................
- 3.3.4 Atributos volatile.................................................................................
- 3.3.5 Modificadores de ámbito de atributos. ...................................................
- 3.4 MÉTODOS
- 3.4.1 Declaración de método..............................................................................
- 3.4.2 Cuerpo del método.
- 3.4.3 Constructores.
- 3.4.4 Destructores..............................................................................................
- 3.5 STRINGS...............................................................................................................
- 3.5.1 La clase String.
- 3.5.2 La clase StringBuffer...............................................................................
- 3.6 LA LÍNEA DE COMANDOS......................................................................................
- 3.7 INTERFACES. ..........................................................................................................
- 3.7.1 Declaración de interface........................................................................
- 3.7.2 Cuerpo del interface................................................................................
- 3.8 LOS PAQUETES.......................................................................................................
- 3.8.1 Declaración de paquetes........................................................................
- 3.8.2 Cómo hacer uso de los paquetes existentes.
- 3.8.3 Paquetes pertenecientes al Java.
- 3.9 EJEMPLO COMPLETO.............................................................................................
- 3.9.1 Generar números aleatorios..................................................................
- 3.9.2 Creación de un bombo............................................................................
- 3.9.3 La clase Resultado.
- 3.9.4 El programa principal............................................................................
- 3.9.5 Modificando la clase Resultado............................................................
- 3.10 CUESTIONES.......................................................................................................
- TRATAMIENTO DE EXCEPCIONES................................................................
- 4.1 LANZAMIENTO DE EXCEPCIONES (THROW). ......................................................
- 4.2 TRATAMIENTO DE EXCEPCIONES. .......................................................................
- 4.2.1 Manejador de excepciones.....................................................................
- 4.3 JERARQUÍA DE EXCEPCIONES...............................................................................
- 4.4 VENTAJAS DEL TRATAMIENTO DE EXCEPCIONES..............................................
- 4.4.1 Separación del código “útil” del tratamiento de errores.................
- 4.4.2 Propagación de errores a través de la pila de métodos.
- 4.4.3 Agrupación y diferenciación de errores..............................................
- 4.4.4 Claridad del código y obligación del tratamiento de errores..........
- 4.5 CUESTIONES.......................................................................................................
- LA ENTRADA/SALIDA EN JAVA.......................................................................
- 5.1 STREAMS. ...............................................................................................................
- 5.2 JERARQUÍA DE CLASES EN EL PAQUETE JAVA.IO. .............................................
- 5.2.1 El paquete java.io en el JDK 1.02.
- 5.2.2 El paquete java.io en el JDK 1.1...........................................................
- 5.3 CLASES IMPORTANTES PARA LA ENTRADA/SALIDA ESTÁNDAR. ...................
- 5.3.1 La clase InputStream...............................................................................
- 5.3.2 La clase OutputStream............................................................................
- 5.3.3 La clase PrintStream...............................................................................
- 5.4 ENTRADA/SALIDA ESTÁNDAR.............................................................................
- 5.5 STREAMS DE CARACTERES...................................................................................
- 5.5.1 La clase Reader........................................................................................
- 5.5.2 La clase Writer.
- 5.5.3 La clase BufferdReader.
- 5.5.4 La clase PrintWriter................................................................................
- 5.6 ENTRADA POR TECLADO Y SALIDA POR PANTALLA. ........................................
- 5.7 FICHEROS................................................................................................................
- 5.7.1 La clase File.
- 5.7.2 La clase FileDescriptor..........................................................................
- 5.7.3 Acceso a ficheros secuenciales.
- 5.7.4 La clase RandomAccessFile.
- 5.7.5 Acceso a ficheros aleatorios..................................................................
- 5.8 SERIALIZACIÓN DE OBJETOS................................................................................
- 5.8.1 Esquema de funcionamiento de la serialización................................
- 5.8.2 Personalización en la serialización.
- 5.9 CUESTIONES.......................................................................................................
- THREADS.....................................................................................................................
- 6.1 ¿QUÉ SON LOS THREADS?.....................................................................................
- 6.1.1 Un ejemplo, mejor que mil palabras....................................................
- 6.1.2 Otro ejemplo.............................................................................................
- 6.1.3 Y otro ejemplo más.
- 6.2 ESTADO DE UN THREAD. ......................................................................................
- 6.3 CREACIÓN DE THREADS........................................................................................
- 6.4 OPERACIONES SOBRE THREADS...........................................................................
- 6.4.1 currentThread().
- 6.4.2 isAlive().
- 6.4.3 sleep().
- 6.4.4 suspend()...................................................................................................
- 6.4.5 wait()..........................................................................................................
- 6.4.6 yield().........................................................................................................
- 6.4.7 join().
- 6.5 THREADS Y SINCRONISMO. ..................................................................................
- 6.5.1 El paradigma productor/consumidor...................................................
- 6.5.2 Sección crítica..........................................................................................
- 6.5.3 Monitores..................................................................................................
- 6.6 PRIORIDAD DE UN THREAD..................................................................................
- 6.7 THREADS DAEMON...............................................................................................
- 6.8 GRUPOS DE THREADS............................................................................................
- 6.8.1 Creación de grupos de threads.
- 6.8.2 Operaciones sobre threads agrupados................................................
- 6.9 CUESTIONES.......................................................................................................
- COMUNICACIONES TCP/IP
- 7.1 INTRODUCCIÓN......................................................................................................
- 7.2 ARQUITECTURA CLIENTE / SERVIDOR. ..............................................................
- 7.3 LA ABSTRACCIÓN SOCKET...................................................................................
- 7.4 SERVICIO SIN CONEXIÓN (DATAGRAM SOCKET)..............................................
- 7.4.1 Creación de un DatagramSocket..........................................................
- 7.5 SERVICIO ORIENTADO A CONEXIÓN (STREAM SOCKET)..................................
- 7.5.1 Operaciones en el servidor....................................................................
- 7.5.2 Espera de conexiones de clientes..........................................................
- 7.5.3 Operaciones en el cliente.......................................................................
- 7.6 CUESTIONES.......................................................................................................
- A. LAS HERRAMIENTAS JAVA...............................................................................
- A.1 JAVAC (COMPILADOR). .........................................................................................
- A.1.1 Opciones....................................................................................................
- A.2 JAVA (INTÉRPRETE)...............................................................................................
- A.2.1 Opciones....................................................................................................
- A.3 JAVAW (INTÉRPRETE). ..........................................................................................
- A.4 JDB (DEPURADOR).................................................................................................
- A.4.1 Comandos básicos...................................................................................
- A.5 JAVAH (GENERADOR DE CABECERAS C)............................................................
- A.6 JAVAP (DESENSAMBLADOR)................................................................................
- A.6.1 Opciones....................................................................................................
- A.7 JAVADOC (GENERADOR DE DOCUMENTACIÓN). ...............................................
- A.7.1 Etiquetas de clase o interface................................................................
- A.7.2 Etiquetas de atributo...............................................................................
- A.7.3 Etiquetas de constructor o método.......................................................
- A.7.4 Opciones....................................................................................................
- B. CONVERSIÓN DE TIPOS.......................................................................................
- B.1 CONVERSIÓN POR AMPLIACIÓN DE TIPOS DE DATOS SIMPLES. .......................
- B.2 CONVERSIÓN POR REDUCCIÓN DE TIPOS DE DATOS SIMPLES..........................
- B.3 CONVERSIÓN POR AMPLIACIÓN DE TIPOS DE DATOS REFERENCIALES...........
- B.4 CONVERSIÓN POR REDUCCIÓN DE TIPOS DE DATOS REFERENCIALES. ...........
- B.5 CONVERSIONES DE TIPOS NO PERMITIDAS.........................................................
- C. LAS CLASES STRING Y STRINGBUFFER.....................................................
- C.1 LA CLASE STRING..................................................................................................
- C.1.1 Constructores de la clase String...........................................................
- C.1.2 Métodos de la clase String.....................................................................
- C.2 LA CLASE STRINGBUFFER....................................................................................
- C.2.1 Constructores de la clase StringBuffer.
- C.2.2 Métodos de la clase StringBuffer.
- D. CLASES ANIDADAS.................................................................................................
- D.1 UTILIDAD DE LAS CLASES ANIDADAS.................................................................
- D.2 CLASES ANIDADAS COMO MIEMBROS DE OTRAS CLASES. ...............................
- D.3 CLASES INTERIORES A UN BLOQUE O LOCALES A UN MÉTODO.......................
- D.4 CLASES ANÓNIMAS. ..............................................................................................
- E. CLASES SOBRE STREAMS Y FICHEROS......................................................
- E.1 LA CLASE INPUTSTREAM.....................................................................................
- E.1.1 Constructor...............................................................................................
- E.1.2 Métodos.....................................................................................................
- E.2 LA CLASE OUTPUTSTREAM.................................................................................
- E.2.1 Constructor...............................................................................................
- E.2.2 Métodos.....................................................................................................
- E.3 LA CLASE PRINTSTREAM.....................................................................................
- E.3.1 Constructores.
- E.3.2 Métodos.....................................................................................................
- E.4 LA CLASE READER................................................................................................
- E.4.1 Atributo......................................................................................................
- E.4.2 Constructores.
- E.4.3 Métodos.....................................................................................................
- E.5 LA CLASE WRITER. ...............................................................................................
- E.5.1 Atributo......................................................................................................
- E.5.2 Constructores.
- E.5.3 Métodos.....................................................................................................
- E.6 LA CLASE BUFFERDREADER. ..............................................................................
- E.6.1 Constructores.
- E.6.2 Métodos.....................................................................................................
- E.6.3 La clase PrintWriter................................................................................
- E.7 LA CLASE FILE.......................................................................................................
- E.8 LA CLASE RANDOMACCESSFILE. .......................................................................
- E.8.1 Constructores.
- E.8.2 Métodos.....................................................................................................
- F. EL FORMATO DE STRINGS UTF-8...................................................................
- F.1 CARACTERES DE UN SOLO BYTE. ........................................................................
- F.2 CARACTERES DE DOS BYTES................................................................................
- F.3 CARACTERES DE TRES BYTES. .............................................................................
- G. CLASES EN JAVA.NET...........................................................................................
- G.1 CLASS SOCKET ......................................................................................................
- G.1.1 CONSTRUCTORES:
- G.1.2 MÉTODOS................................................................................................
- G.2 CLASS SERVERSOCKET ........................................................................................
- G.2.1 CONSTRUCTORES:
- G.2.2 MÉTODOS................................................................................................
- G.3 CLASS DATAGRAMSOCKET.................................................................................
- G.3.1 CONSTRUCTORES.................................................................................
- G.3.2 MÉTODOS................................................................................................
- G.4 CLASS INETADDRESS............................................................................................
- G.4.1 MÉTODOS................................................................................................
- G.5 CLASS DATAGRAMPACKET.................................................................................
- G.5.1 CONSTRUCTORES.................................................................................
- G.5.2 MÉTODOS................................................................................................
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.
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.
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 americano^2 ). 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!”.
Introducción.
ocurrido con otras tecnologías y aplicaciones, se han descubierto, y posteriormente subsanado, “agujeros” en la seguridad^3 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.
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.
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 revolucionaria^4 del lenguaje. Es la entidad que proporciona la independencia de plataforma para los programas Java “compilados” en byte-code.
Programa fuente
ByteCode
Código máquina 1
Compilación (Javac)
F.java
Código máquina 2
Código máquina 3
JVM para la máquina 1
JVM para la máquina 2
JVM para la máquina 3
Clase1.class Clase2.class ClaseN.class
(^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.
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.
Introducción.
- Un desensamblador de clases: javap.exe
- El generador de archivos fuentes y de cabecera (.c y .h) para clases nativas en C: javah.exe
1.6.2 Estructura de directorios.
.hotJava: Es donde se almacenan los ficheros de configuración del navegador de Sun HotJava.
bin: Es donde se almacenan los ficheros ejecutables del entorno de desarrollo: javac, jdb, java y appletviewer.
demo: Contiene varios directorios con ejemplos de programas y applets escritos en Java.
include: Contiene cabeceras para utilizar funciones escritas en C.
lib: Contiene las librerías de clases proporcionadas por el lenguaje. Estas librerías se encuentran comprimidas en el fichero classes.zip.
N Atención, este último fichero no se debe
descomprimir.
1.6.3 Configuración.
En este caso se va a suponer que el JDK ha sido instalado en el directorio c:\java. En otro caso, bastaría con sustituir éste por el directorio realmente utilizado.
Introducción.
En primer lugar, para poder ejecutar el compilador javac y poder interpretar los programas “ejecutables” resultantes, hay que añadir en el path la localización de los ejecutables del entorno de desarrollo, modificando el fichero autoexec.bat de la siguiente forma:
path = c:\java\bin; …..
También hay que añadir en él una variable CLASSPATH que contendrá el/los directorios donde se almacenan las clases.
set CLASSPATH = c:\java\lib; c:\Java\MisClases;. ; ….
Es conveniente incluir el directorio actual (. ) para poder acceder a las clases que se están creando en un determinado directorio en un momento dado.
1.7 Programación orientada a objetos.
Antes de empezar a estudiar en detalle el lenguaje Java, es imprescindible conocer los conceptos y características particulares de la programación orientada a objetos (POO). No sólo es importante que este punto sea leído por quien desconoce la POO sino que también es importante que lo lea quien la conoce, ya que existen distintas terminologías para nombrar los mismos conceptos.
La programación orientada a objetos es una evolución lógica de la programación estructurada, en la que el concepto de variables locales a un procedimiento o función, que no son accesibles a otros procedimientos y funciones, se hace extensible a los propios subprogramas que acceden a estas variables. Pero la programación orientada a objetos va mucho más allá. En realidad, cambia la concepción de la metodología de diseño de los programas.
En la programación orientada a objetos, se definen objetos que conforman una aplicación. Estos objetos están formados por una serie de características y operaciones que se pueden realizar sobre los mismos. Estos objetos no están aislados en la aplicación, sino que se comunican entre ellos.
1.7.1 ¿Qué es un objeto?
La respuesta a esta pregunta en términos ajenos a la programación parece simple. Un objeto es una persona, animal o cosa. Se distingue de otros objetos por tener unas determinadas características y “sirve” para algo, o dicho de otra forma, se pueden realizar distintas operaciones con/sobre ese objeto.
