Download CAPÍTULO 10: PAQUETES. EL API DE JAVA ÍNDICE

Dpto. Electrónica y
Telecomunicaciones
CAPÍTULO 10: PAQUETES. EL API DE JAVA
ÍNDICE
1
2
3
4
Introducción: ¿qué es un paquete?........................................................................................................2
¿Para qué sirven?..................................................................................................................................3
¿Cómo crear un paquete? .....................................................................................................................4
¿Cómo importar un paquete?................................................................................................................6
4.1 La variable CLASSPATH..............................................................................................................7
4.2 Ficheros JAR..................................................................................................................................7
5 El API de Java (JDK API o núcleo de Java). Paquetes de Java..........................................................11
5.1 java.applet ....................................................................................................................................11
5.2 java.awt ........................................................................................................................................11
5.3 java.io...........................................................................................................................................11
5.4 java.lang .......................................................................................................................................12
5.4.1
La clase Object ...................................................................................................................12
5.5 java.net .........................................................................................................................................12
5.6 java.util.........................................................................................................................................13
5.7 Otros paquetes..............................................................................................................................13
5.8 Ayuda del API..............................................................................................................................14
6 Ejercicios propuestos..........................................................................................................................16
7 Referencias .........................................................................................................................................17
7.1 Bibliografía ..................................................................................................................................17
7.2 Internet .........................................................................................................................................17
Java – Introducción a la programación
1
Capítulo 10: Paquetes. El API de Java
1 INTRODUCCIÓN: ¿QUÉ ES UN PAQUETE?
En Java, los programas se organizan como conjuntos de paquetes (en inglés, packages). Los paquetes
no son más que conjuntos de clases, interfaces y tipos, organizados de forma jerárquica, y almacenados
bien en un sistema de ficheros o bien en una base de datos.
La palabra clave package permite agrupar clases e interfaces. Los nombres de los paquetes son
palabras separadas por puntos y se almacenan en directorios que coinciden con esos nombres.
Por ejemplo, los ficheros siguientes, que contienen código fuente Java:
Applet.java, AppletContext.java, AppletStub.java, AudioClip.java
contienen en su código la línea:
package java.applet;
Y las clases que se obtienen de la compilación de los ficheros anteriores, se encuentran con el nombre
nombre_de_clase.class, en el directorio:
java/applet o bien java\applet, dependiendo del sistema operativo.
El propio núcleo de Java, con todas sus librerías de clases, hace uso de los paquetes para clasificarlas.
hAlgunos de los paquetes que proporciona el lenguaje y que posteriormente veremos en detalle son:
•
•
•
•
•
java.applet
java.awt
java.io
java.lang
java.util
Toda clase debe pertenecer a un paquete. Si se omite la sentencia package, se considera que el fichero
pertenece al paquete por defecto, es decir, un paquete sin nombre, y los ficheros que se obtengan de su
compilación se almacenarán en el directorio por defecto, es decir, el mismo directorio en el que se
encuentra el fichero fuente.
Como se ha visto implícitamente en el ejemplo anterior, se pueden establecer jerarquías de paquetes, de
forma que en el paquete java.applet, el paquete ‘applet’ es un ‘subpaquete’ del paquete principal ‘java’.
Esto nos ayuda aún más a agrupar y organizar nuestro código.
Java – Introducción a la programación
2
Capítulo 10: Paquetes. El API de Java
2 ¿PARA QUÉ SIRVEN?
Los paquetes tienen dos finalidades diferenciadas: la primera, agrupar clases, interfaces y tipos a modo
de unidades de librería, es decir, mejorar la organización de las clases y, la segunda, emplear, de forma
homogénea, dichas unidades en cualquier aplicación que desarrollemos, de forma que también se facilita
el intercambio de código entre los programadores. Esto es lo que hacemos, por ejemplo, al utilizar la
siguiente sentencia en el código:
import java.util.*;
Lo que estamos haciendo con la palabra clave import es cargar la biblioteca de utilidades, que en este
caso es parte de la distribución estándar de Java, como ya veremos, para poder utilizar cualquiera de sus
clases en nuestra aplicación.
También se puede incorporar una única clase, por ejemplo, ArrayList del paquete java.util,
por ejemplo:
import java.util.ArrayList;
Aunque de esta forma no estarán disponibles ninguna de las otras clases del paquete java.util. Si
no utilizáramos import, podríamos utilizar dicha clase en nuestro programa, pero deberíamos invocarla
con su nombre completo java.util.ArrayList.
La utilidad de emplear paquetes es mayor cuando, bien se utiliza un número elevado de clases en un
programa (decenas, cientos…), o bien incorporamos a nuestros programas clases desarrolladas por otros
programadores, que puede que coincidan en nombre con algunas de las nuestras. Esto último podría
parecer un problema, pero Java lo resuelve de forma que las clases dentro de un paquete son
referenciadas en términos de su paquete (se podría decir que cada paquete tiene un nuevo espacio de
nombres). De esta forma, los paquetes nos permiten evitar conflictos entre nombres de clases.
Los paquetes también permiten controlar la visibilidad de las clases y métodos que se definan en él.
Además de los modificadores public, protected y private, que ya han sido estudiados en el
tema 5, una clase o miembro de clase sin modificador perteneciente a un paquete es accesible a las
clases del mismo paquete.
Java – Introducción a la programación
3
Capítulo 10: Paquetes. El API de Java
3 ¿CÓMO CREAR UN PAQUETE?
Como ya hemos comentado, la palabra clave package nos permite indicar que una clase pertenece a un
paquete, de la siguiente forma:
package mipaquete;
class miclaseA {
. . .
}
class miclaseB {
. . .
}
En este fichero, se crea un paquete llamado “mipaquete” y todas las clases definidas en ese código serán
miembros del paquete creado. Por tanto, miclaseA y miclaseB son miembros del paquete
mipaquete.
Por otra parte, el siguiente código:
package mipaqueteA;
package mipaqueteB;
class miclaseA {
. . .
}
class miclaseB {
. . .
}
Nos devolvería un error, ya que no es posible incluir más de una sentencia package por fichero, es
decir, si queremos que estas dos clases pertenezcan a paquetes diferentes, deberíamos declararlas en
ficheros independientes, con su sentencia package correspondiente.
El nombre completo de una clase incluye como prefijo el paquete al que pertenece. Por tanto, en el
ejemplo anterior el nombre completo de las clases no será miclaseA y miclaseB, sino
mipaquete.miclaseA y mipaquete.miclaseB.
De este modo, si quisiéramos ejecutar cualquiera de estas clases por línea de comandos, deberíamos
hacerlo de esta forma:
java mipaquete.miclaseA
De la misma manera, si queremos referenciarlas desde otras clases, deberíamos indicar su nombre
completo:
mipaquete.miclaseA
En este ejemplo, hemos declarado dos clases dentro de un mismo fichero y ambas se han incluido en el
mismo paquete, si bien podríamos haberlas declarado en ficheros distintos pero ambas incluidas en el
mismo paquete, lo cual suele ser más habitual en programas con varios ficheros fuente. Por ejemplo:
Java – Introducción a la programación
4
Capítulo 10: Paquetes. El API de Java
•
Fichero miclaseA.java:
package mipaquete;
class miclaseA {
. . .
}
•
Fichero miclaseB.java:
package mipaquete;
class miclaseB {
. . .
}
Como ya hemos comentado anteriormente, la compilación de estos ficheros generará dos ficheros .class
(miclaseA.class y miclaseB.class) en el directorio mipaquete, coincidente con el nombre del paquete
al que pertenecen. Normalmente, esta estructura se generará bien en el directorio de trabajo actual
(indicado por el propio compilador) o bien en el directorio indicado por la variable de entorno
CLASSPATH. Esta variable contiene las rutas de búsqueda de las clases que se pueden utilizar desde
nuestros programas, incluyendo la ruta de la jerarquía de clases del núcleo del lenguaje Java, y
normalmente se inicializa al instalar el propio kit de desarrollo de Java (JDK) o, en su caso, el compilador,
aunque también puede modificarse manualmente para ubicar nuestras clases y paquetes en cualquier
lugar del sistema de ficheros.
Una vez las hayamos compilado, estas clases podrán ser utilizadas (importadas) desde otros programas,
como veremos en el siguiente apartado.
Java – Introducción a la programación
5
Capítulo 10: Paquetes. El API de Java
4 ¿CÓMO IMPORTAR UN PAQUETE?
Cuando queremos acceder en nuestro programa a clases que no pertenecen a nuestro mismo paquete,
debemos referirnos a ellas utilizando su nombre completo. Por ejemplo, si queremos acceder a la clase
Rectangle y Circle o a la clase Vector del paquete java.util debemos hacerlo de la siguiente manera:
package miotroPaquete;
class MiOtraClase{
...
graphics.Circle c = new graphics.Circle( );
graphics.Rectangle r = new graphics.Rectangle( );
java.util.Vector v = new java.util.Vector( );
...
}
Sin embargo, para acortar el código y poder utilizar las clases de un paquete o bien un paquete entero, se
utiliza la palabra clave import, especificando el nombre de paquete como ruta y nombre de clase (es lo
mismo que la palabra clave #include de C/C++). La sentencia import se debe incluir después de la
sentencia package y antes de las definiciones de clases. Se pueden cargar todas las clases de un
paquete (no los subpaquetes), utilizando el comodín o asterisco (*).
import java.Date;
import java.util.Vector;
import java.util.*;
El empleo del comodín obliga al compilador a cargar en memoria todas las clases de un determinado
paquete, por lo que se recomienda emplearlo en aquellos casos en que el número de clases del paquete
a utilizar sea elevado, ya que de lo contrario puede ralentizar en exceso la compilación.
En el caso de un fichero fuente Java con una clase que no pertenece a ningún paquete, ésta puede ser
cargada con la sentencia import, ya que se coloca en el paquete por defecto sin nombre.
import miClase;
Al importar un paquete, sólo son accesibles sus elementos declarados como públicos; sin embargo, si en
nuestro programa hay clases que heredan de algunas de las declaradas en el paquete, podremos
acceder también a los elementos protegidos de la superclase.
Si tratamos de utilizar en nuestro programa una clase de un paquete que no ha sido importado, el
compilador nos devolverá un mensaje de error similar a éste:
prueba.java:9: Class Vector not found in type declaration.
Vector v = new Vector();
^
Como veremos al hablar de los paquetes del núcleo del lenguaje Java, existen ciertos paquetes, como el
paquete java.lang, que son importados automáticamente por el JDK y que por tanto no es necesario
importar explícitamente.
Java – Introducción a la programación
6
Capítulo 10: Paquetes. El API de Java
4.1 La variable CLASSPATH
Ya hemos dicho que lo más común es que una aplicación conste de un conjunto de clases interactuando
entre sí. El código de estas clases puede pertenecer a distintos paquetes y no tiene porqué estar ubicado
en un mismo directorio. La máquina virtual de Java (JVM, Java Virtual Machine) busca por defecto un
fichero con el nombre de la clase y extensión .class, pero es necesario indicarle dónde (en qué
directorios) debe buscarlos.
Sabemos que nuestro sistema, cuando tratamos de acceder a un comando o fichero ejecutable, dispone
de una lista de directorios en los que se encuentran estos comandos. Esta lista se almacena en la
variable de entorno PATH que, por ejemplo, contiene los directorios /bin, /usr/bin, /usr/sbin, etc. en el caso
de un sistema Linux. Esa es la función de la variable de entorno CLASSPATH para la búsqueda de clases
Java.
La variable CLASSPATH contiene una lista de localizaciones (directorios o rutas de ficheros JAR) donde
se deben buscar las clases compiladas. Por ejemplo, para un sistema MS-DOS, Windows:
CLASSPATH=.;C:\JDK1.4.0\LIB;C:\MISCLASES\FICHERO.JAR
Aunque el propio kit de desarrollo de Java (JDK) o bien el compilador que instalemos suelen configurar
por defecto el valor de esta variable, es posible modificarlo mediante comandos del sistema, como set,
para añadir rutas de paquetes o ficheros empleados por nosotros. Por ejemplo:
set CLASSPATH=C:\EJEMPLOS;C:\TEMP\CLASSES.JAR
Debemos tener en cuenta en estos casos que el valor de la variable habrá que configurarlo siempre para
que apunte al directorio anterior a donde comienza una estructura de directorios de un paquete que
queremos utilizar. Por ejemplo, la estructura correspondiente al paquete mipaquete.misubpaquete se
encuentra en el directorio c:\ejemplos, de ahí que hayamos incluido este directorio en el CLASSPATH del
sistema.
4.2 Ficheros JAR
Si bien no están directamente relacionados con el concepto de paquetes en Java, desde la versión 1.1
del lenguaje es muy común el empleo de ficheros JAR (Java Archives) para el intercambio de clases
entre programadores o bien para la extensión del API de Java con clases avanzadas, por lo que veremos
en este punto una breve introducción a estos ficheros, a su creación y a su utilización.
Un fichero JAR es una forma de agrupar un grupo de archivos en un único fichero comprimido, que
emplea el comúnmente conocido formato ZIP. El contenido típico de un fichero JAR son las clases y
recursos adicionales (imágenes, archivos de texto, ayuda…) asociados con applets o aplicaciones. La
extensión de estos ficheros es típicamente .jar, aunque no es obligatorio.
La utilidad de los ficheros JAR es más clara cuando pensamos en aplicaciones a través de Internet.
Antes, por ejemplo, un navegador web que quisiera visualizar un applet (una miniaplicación que se
ejecuta en un navegador), tenía que realizar tantas conexiones contra el servidor como ficheros (sin
comprimir) tuviera la aplicación en cuestión. Esto provocaba que muchos programadores trataran de
escribir sus aplicaciones incluyendo todo el código en una única clase, con la consiguiente complejidad
para entender y actualizar dicho fichero fuente.
Java – Introducción a la programación
7
Capítulo 10: Paquetes. El API de Java
Con la llegada del formato JAR, todos los archivos de un applet pueden agruparse en un único fichero, de
forma que sólo es necesaria una petición al servidor y, además, como el fichero está comprimido, la
transferencia es más rápida.
Otras de las múltiples ventajas de los ficheros JAR son:
•
•
•
•
•
Seguridad: pueden firmarse digitalmente para garantizar la autenticidad de los
programas que contienen y su origen.
Portabilidad: no sólo porque los contenidos de un JAR son multiplataforma, sino porque
el manejo de los mismos (comando jar, entre otros) es una parte estándar del núcleo de
la API de Java.
Extensibilidad: los ficheros JAR permiten añadir funcionalidades al núcleo de Java (o
bien a nuestras aplicaciones), mediante el empaquetado de extensiones. Por ejemplo, el
paquete javax.swing, que veremos en el capítulo 12, se incorporaba a las versiones
antiguas de Java como una extensión en un fichero JAR.
Sellado: opcionalmente se puede obligar a que los paquetes incluidos en un fichero JAR
exijan consistencia de versión, es decir, que todas las clases incluidas deban encontrarse
en el mismo fichero JAR de la versión correspondiente.
Información: un fichero JAR permite incorporar datos acerca de los ficheros que
contiene, como el proveedor o la información de versión.
La utilidad jar, contenida en el JDK de Sun, comprime automáticamente los archivos que se seleccionen,
e incorpora, en caso de que el programador no lo haya hecho, archivos de declaración (manifest, en
inglés) que los describen. La forma de invocar el comando jar desde la línea de comandos es la siguiente:
jar [opciones] destino [declaracion] archivo/s de entrada
Las opciones son una serie de letras que se asemejan a las opciones del comando tar de Linux. Algunas
de las opciones más comunes son:
c
t
x
x fichero
f
v
0 (cero)
M
Crear un archivo nuevo o vacío.
Listar la tabla de contenidos.
Extraer todos los archivos.
Extraer el fichero indicado.
Indica el nombre del fichero. En caso de no indicarlo, la
entrada (o salida) empleadas serán las estándar.
Generar una salida que describa lo que va haciendo el
comando jar.
Almacenar archivos, sin comprimir. Se emplea para crear
ficheros JAR que puedan ponerse en el CLASSPATH
No crear automáticamente un archivo de declaración.
Si se indica algún subdirectorio en los ficheros a añadir, se añade éste automáticamente, así como todos
sus subdirectorios, y se mantiene la información acerca de las rutas (también se puede omitir con la
opción C).
Por ejemplo, el comando siguiente:
jar cvf miEjemploJar.jar *.class
Java – Introducción a la programación
8
Capítulo 10: Paquetes. El API de Java
Genera un fichero de nombre miEjemploJar.jar que contendrá todos los archivos de clases del directorio
actual y lo coloca en ese mismo directorio, ofreciéndonos información de lo que el comando va haciendo.
Además, genera un fichero de declaración (en la ruta META-INF/MANIFEST.MF). Este fichero permite
que los ficheros JAR soporten el firmado digital, el control de versiones y otras funcionalidades que ya
hemos comentado. Se trata de un fichero especial, que contiene información (nombres, rutas de acceso y
firmas digitales) sobre los archivos ‘empaquetados’, por ejemplo:
Manifest-Version: 1.0
Name: java/math/BigDecimal.class
SHA1-Digest: TD1GZt8G11dXY2p4olSZPc5Rj64=
MD5-Digest: z6z8xPj2AW/Q9AkRSPF0cg==
Name: java/math/BigInteger.class
SHA1-Digest: oBmrvIkBnSxdNZzPh5iLyF0S+bE=
MD5-Digest: wFymhDKjNreNZ4AzDWWg1Q==
Cocoon-Libs: avalon-excalibur-4.1.jar commons-httpclient20011012.jar
commons-collections-1.0.jar
xml-apis.jar
xercesImpl-2.0.0.jar
Cocoon-Lib-avalon-excalibur-4_1_jar: 1017127213000
Cocoon-Lib-commons-httpclient-20011012_jar: 1017127213000
Cocoon-Lib-commons-collections-1_0_jar: 1017127214000
Cocoon-Lib-xml-apis_jar: 1017127214000
Cocoon-Lib-xercesImpl-2_0_0_jar: 1017127215000
Siguiendo con jar, en este otro ejemplo:
jar cvf miOtroEjemploJar.jar classes sonido imagenes
Genera un fichero de nombre miOtroEjemploJar.jar que contendrá todos los archivos y subdirectorios de
los directorios classes, sonido e imagen. La información ofrecida al indicar la opción v sería algo similar a
lo siguiente:
adding:
41%)
adding:
adding:
adding:
adding:
adding:
adding:
adding:
adding:
adding:
classes/claseA.class (in=3825) (out=2222) (deflated
sonido/ (in=0) (out=0) (stored 0%)
sonido/be.au (in=4032) (out=3572) (deflated 11%)
sonido/di.au (in=2566) (out=2055) (deflated 19%)
sonido/ren.au (in=6558) (out=4401) (deflated 32%)
sonido/ya1.au (in=7834) (out=6985) (deflated 10%)
sonidoo/ya2.au (in=7463) (out=4607) (deflated 38%)
imagenes/ (in=0) (out=0) (stored 0%)
imagenes/cruz.gif (in=157) (out=160) (deflated -1%)
imageness/no.gif (in=158) (out=161) (deflated -1%)
En el siguiente ejemplo:
jar xf miOtroEjemploJar.jar classes/claseA.class
El comando jar realiza una copia de el/los archivo/s indicado/s, creando, si es necesario, la estructura de
directorios que tenían en el archivo. Si no hubiésemos indicado el archivo a extraer, el comando los
habría extraído todos:
jar xf miOtroEjemploJar.jar
Java – Introducción a la programación
9
Capítulo 10: Paquetes. El API de Java
Finalmente, una vez visto cómo empaquetar y extraer archivos de un fichero JAR, vamos a ver cómo se
utilizan los paquetes y aplicaciones contenidos en él.
La forma de ejecutar código empaquetado en un fichero JAR depende del tipo de aplicación de que se
trate: un applet ejecutable desde un navegador, una aplicación independiente o una extensión o driver
para incorporar a nuestros programas. Cada una de estas opciones tiene sus particularidades, pero ya
hemos visto que la opción O permite crear ficheros JAR sin comprimir, de forma que podemos dejarlos en
el CLASSPATH de nuestro sistema y el propio compilador podrá buscar archivos de clases en ellos.
En realidad, la mayoría del software distribuido en forma de ficheros JAR contiene instrucciones sobre
cómo utilizarlo: la ruta donde hay que dejar los ficheros (normalmente en el mismo directorio que la
aplicación que va a hacer uso de ellos o bien en alguno de los directorios indicados por la variable
CLASSPATH), si es necesario realizar alguna configuración del sistema, cómo invocar las clases o
aplicaciones, etc. Por ello, la mejor recomendación para utilizar código distribuido de esta forma (como
para cualquier otra aplicación software) es que se lea bien la documentación que lo acompaña en cada
caso, y que suele estar contenida en ficheros simples de texto (README, Howto, Version).
Java – Introducción a la programación
10
Capítulo 10: Paquetes. El API de Java
5 EL API DE JAVA (JDK API O NÚCLEO DE
JAVA). PAQUETES DE JAVA
El núcleo del lenguaje Java proporciona una serie de paquetes que incluyen ventanas, utilidades, un
sistema de entrada/salida general, herramientas y comunicaciones. Los paquetes Java que se incluyen
son java.applet, java.awt, java.io, java.lang, java.net, java.util. Vamos a describir cada uno de ellos
brevemente a continuación.
5.1 java.applet
Este paquete contiene clases diseñadas para usar con applets. Hay una clase Applet y tres interfaces:
AppletContext, AppletStub y AudioClip.
5.2 java.awt
El paquete Abstract Windowing Toolkit (awt) contiene clases para generar componentes GUI (Graphic
User Interface - Interfaz Gráfico de Usuario): ventanas, botones, menús, listas, barras de desplazamiento,
cuadros de diálogo, cuadros de texto, etc. Incluye, entre otras, las clases Button, Checkbox, Choice,
Component, Graphics, Menu, Panel, TextArea y TextField.
5.3 java.io
El paquete de entrada/salida contiene toda la gestión de entradas y salidas a ficheros o strings, que en
Java se realizan en forma de flujos (streams). Algunas de sus clases más importantes son:
•
•
•
•
•
•
•
•
•
BufferedInputStream: se trata de una clase que permite leer datos a través de un stream con
un buffer intermedio.
BufferedOutputStream: implementa los métodos para escribir en un stream a través de un
buffer.
File: representa los pathname de ficheros y directorios.
FileInputStream: permite leer bytes de un fichero.
FileOutputStream: permite escribir bytes en un fichero o descriptor.
RandomAccessFile: las instancias de esta clase permiten leer o escribir en ficheros de acceso
aleatorio.
StreamTokenizer: esta clase recibe un stream de entrada y lo divide (parsea) en diversos
pedazos (tokens), permitiendo leer uno en cada momento.
StringReader: es un stream de caracteres cuya fuente es una cadena de caracteres o string.
StringWriter: es un stream de caracteres cuya salida es un buffer de cadena de caracteres, que
puede utilizarse para construir un string.
Java – Introducción a la programación
11
Capítulo 10: Paquetes. El API de Java
5.4 java.lang
Se puede decir que es el paquete central de Java. Incluye las clases del lenguaje Java propiamente dicho
(por ejemplo, Integer, Long, Float, Double…) y es importado implícitamente en todos los programas.
Algunas de las clases cuyas definiciones contiene son:
•
•
•
•
•
•
Object: es la clase central de Java y raíz de la jerarquía de clases. Todas las clases la heredan
implícitamente.
Math: es la clase que contiene las constantes E y PI y las funciones matemáticas más comunes:
sin, cos, max, min, random, etc.
String y StringBuffer: para el manejo de cadenas de caracteres.
Thread: significa ‘hilo’ y es la clase base para la programación concurrente o ejecución
multiproceso (en Java, multi-hilo), es decir, la posibilidad de que un programa realice varias
acciones al mismo tiempo.
Throwable: es la superclase de la jerarquía de las excepciones y errores de Java.
Class: representa las clases en la aplicación que se está ejecutando, de forma que hay una
instancia de Class para cada clase cargada.
5.4.1La clase Object
Ya hemos comentado que la clase estándar Object es la superclase de todas las demás, por lo que todos
los objetos tendrán un conjunto común de métodos, heredados de esta clase y, además, una referencia a
este objeto de tipo Object nos servirá para referirnos a cualquier clase de objeto.
Algunos de los métodos de la clase Object, heredados por cualquier objeto, son:
•
•
•
•
•
•
public String toString ( ) – permite que todos los objetos sean representables en forma de
cadena de caracteres. devuelve una representación en forma de cadena de caracteres del
objeto. Es el método al que llama el operador sobrecargado + sobre strings.
protected Object clone ( ) – crea un nuevo objeto duplicado, es decir, devuelve una copia del
objeto. Sólo pueden duplicarse aquellas clases que implementan la interfaz cloneable, sino se
devolverá una excepción de tipo CloneNotSupportedException.
public boolean equals (Object obj) – indica si un objeto es igual a otro.
public final Class getClass ( ) – devuelve la clase (objeto Class) de un objeto.
public final void wait (…), public final void notify ( ), public final void notifyAll ( ) – son
métodos utilizados en programación concurrente.
protected void finalize ( ) – se ejecuta antes de destruirse el objeto.
5.5 java.net
Este paquete da soporte para la programación de aplicaciones en red. En concreto, permite trabajar con
todos los elementos asociados a conexiones del protocolo TCP/IP y, además, incluye las clases Socket,
URL y URLConnection para el manejo de otro tipo de conexiones de red.
Java – Introducción a la programación
12
Capítulo 10: Paquetes. El API de Java
5.6 java.util
Este paquete es una miscelánea de clases útiles para muchas cosas en programación, como estructuras
de datos dinámicas, fecha y hora, etc. Se incluyen, entre otras clases, Date (fecha), Vector (arrays o
vectores dinámicos), Dictionary (diccionario), Random (números aleatorios), Stack (pila FIFO),
StringTokenizer (útil para dividir cadenas de caracteres en subcadenas o tokens en función de
caracteres de separación).
5.7 Otros paquetes
A continuación, se describen brevemente otros paquetes del API de Java, no tan básicos como los
anteriores
•
•
•
•
•
•
java.beans: define componentes software utilizables en cualquier aplicación.
java.math: paquete de utilidades matemáticas. Dispone de algunas funciones matemáticas
adicionales, fundamentalmente la gestión de números enteros y reales muy grandes (de
magnitud no limitada).
java.rmi: invocación remota de métodos (RMI, Remote Method Invocation).
java.security: dispone de clases relacionadas con seguridad: autenticación, firma digital,
criptografía, etc.
java.sql: contiene clases para el manejo de bases de datos SQL (Structured Query Language)
desde aplicaciones Java (JDBC, Java Database Conectivity).
java.text: dispone de utilidades relacionadas con texto (formato de números, fechas, recorrido
de strings, etc.)
Y otras extensiones más avanzadas de la API son las siguientes:
•
•
•
•
•
•
Java Media API: permite gestionar todo tipo de medios (gráficos, vídeo, sonido…) definidos en
seis áreas: Java 2D, Java 3D, Java Media Framework, Java Telephony, Java Share, Java
Animation.
Java Enterprise API: consta de una serie de librerías que ofrecen conectividad a bases de
datos y aplicaciones distribuidas: JDBC, IDL, RMI.
Java Commerce API: orientada al comercio telemático (mal llamado electrónico).
Java Embedded API: diseñada para dispositivos embebidos, incapaces de soportar el API
completo. Contiene la funcionalidad mínima (java.lang, java.util y parte de java.io) y una serie de
extensiones para comunicaciones y GUI.
Java Server API: extensión que permite el desarrollo de servidores de red.
Java Management API: contiene objetos y métodos para construir aplicaciones sobre una red
corporativa.
Java – Introducción a la programación
13
Capítulo 10: Paquetes. El API de Java
5.8 Ayuda del API
Como el lector habrá podido imaginar, no es posible conocer de memoria todas las clases, paquetes,
métodos, etc. que hemos enumerado en los apartados anteriores. Algunos compiladores ‘inteligentes’ son
capaces de generar código de manera automática para crear partes de nuestra aplicación, o bien
consultar directamente la ayuda del API de cada clase para proponernos métodos que podamos utilizar
en un punto concreto del código que estemos escribiendo.
Para los programadores que empiezan en Java, lo más común suele ser utilizar un compilador más o
menos sencillo (ya que sino podría resultar más complejo aprender a manejarlo que dominar el propio
lenguaje de programación) y hacer uso de la documentación que acompaña al kit de desarrollo de Java
(JDK) que tengamos instalado para consultar la ayuda acerca de un paquete, clase o método que
desconocemos.
En general, podremos acceder a
C:\<Directorio_JDK>\docs\api\index.html
la
ayuda
del
JDK
que
tengamos
instalado
en
La apariencia de la interfaz de ayuda de la API se presenta en la siguiente figura:
Figura 1. Interfaz de ayuda del API Java 1.4.0
Como se puede observar, la ayuda aparece en formato HTML con frames (aunque también existe la
posibilidad de visualizar la versión sin frames) distinguiéndose las siguientes partes:
•
Parte izquierda: consta de dos frames. En el frame superior aparecen todos los paquetes del
API en orden alfabético y, en el frame de la parte inferior, al pinchar sobre un paquete,
aparecerán todos los elementos (interfaces y clases) que contiene.
Java – Introducción a la programación
14
Capítulo 10: Paquetes. El API de Java
•
Parte derecha: consta de un único frame en el que aparecerá la ayuda acerca del elemento
seleccionado. En la parte superior del mismo, disponemos de un menú para ver un índice
alfabético (index), el árbol de la jerarquía (Tree), las clases deprecadas (Deprecated) y otra serie
de funcionalidades. Más abajo, en caso de haber consultado una clase, veremos su jerarquía de
clases, una breve explicación de su funcionamiento, sus constructores, un resumen de los
métodos que contiene (propios y heredados) y cada uno de éstos explicados en detalle. También
se suele disponer de ejemplos ilustrativos del funcionamiento de alguno de los métodos.
Java – Introducción a la programación
15
Capítulo 10: Paquetes. El API de Java
6 EJERCICIOS PROPUESTOS
1.- Crear, en un fichero de nombre Espacio.java, una clase Espacio, que tenga los atributos
volumen y superficie, así como los métodos volumen( ) y superficie( ), cuyos
parámetros de salida serán, tal y como indican sus nombres, el volumen y la superficie de ese espacio.
2.- Crear tres clases derivadas de Espacio: Cubo, Esfera y Cilindro. Estas clases deberán
estar en ficheros independientes, pero deben pertenecer al paquete Espacio. Los constructores de
estas clases deberán definirse de forma que, al pasarles como parámetro la longitud del lado, el radio y la
altura y el radio de la base, respectivamente, calculen automáticamente el volumen y la superficie.
3.- Cada una de las clases deberá tener un atributo de clase volumenTotal, que guarde el volumen
total de todos los objetos creados de esa clase; así, el atributo de clase volumenTotal para la clase
Espacio debe sumar los volúmenes totales de todas las instancias de sus subclases (no se debe
instanciar la clase Espacio como tal).
4.- Finalmente, crear una clase testEspacio (que no esté en el mismo paquete), cuyo método
principal (main) realice las siguientes operaciones: inicializar un Cubo de lado 7, una Esfera de radio 5,
y un Cilindro de radio de la base 3 y altura 6, visualizar el volumen de los mismos a medida que se van
creando, así como el volumen total. La clase testEspacio debe hacer uso del paquete figura para
realizar estas operaciones.
Java – Introducción a la programación
16
Capítulo 10: Paquetes. El API de Java
7 REFERENCIAS
7.1 Bibliografía
•
•
Bruce Eckel. Piensa en Java. 2ª edición. Pearson Educación - Prentice Hall. Madrid. 2002.
Tema 5. Ocultar la implementación. El paquete: la unidad de biblioteca.
James Gosling, Hill Joy, Guy Steele, Gilad Bracha. The Java Language Specification. 2nd edition.
Addison-Wesley. California (USA). 2000.
Tema 7. Packages.
7.2 Internet
•
•
The Java Tutorial.
URL: http://java.sun.com/docs/books/tutorial/
Creating and Using Packages.
URL: http://java.sun.com/docs/books/tutorial/java/interpack/packages.html
Tutorial de Java de Agustín Froufe.
Paquetes.
URL: http://orion.qro.itesm.mx/~java/tutorial/JavaTutorial/Cap1/paquete.html
Java – Introducción a la programación
17