Paquetes X

8/20/2019 Paquetes X

1/17

Java – Introducción a la programación 1

CAPÍTULO 10: PAQUETES. EL API DE JAVA

ÍNDICE

1 Introducción: ¿qué es un paquete?........................................................................................................2 2 ¿Para qué sirven?..................................................................................................................................3 3 ¿Cómo crear un paquete? ........................................................ ............................................................. 4 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

Dpto. Electrónica yTelecomunicaciones


2/17

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 paquetesno 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 sonpalabras 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 nombrenombre_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 ficheropertenece al paquete por defecto, es decir, un paquete sin nombre, y los ficheros que se obtengan de sucompilación se almacenarán en el directorio por defecto, es decir, el mismo directorio en el que seencuentra el fichero fuente.

Como se ha visto implícitamente en el ejemplo anterior, se pueden establecer jerarquías de paquetes, deforma 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.


3/17



2 ¿PARA QUÉ SIRVEN?

Los paquetes tienen dos finalidades diferenciadas: la primera, agrupar clases, interfaces y tipos a modode 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 facilitael intercambio de código entre los programadores. Esto es lo que hacemos, por ejemplo, al utilizar lasiguiente 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 susclases 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 unprograma (decenas, cientos…), o bien incorporamos a nuestros programas clases desarrolladas por otrosprogramadores, que puede que coincidan en nombre con algunas de las nuestras. Esto último podríaparecer 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 denombres). 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 lasclases del mismo paquete.


4/17



3 ¿CÓMO CREAR UN PAQUETE?

Como ya hemos comentado, la palabra clave package nos permite indicar que una clase pertenece a unpaquete, 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ánmiembros 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 enficheros independientes, con su sentencia package correspondiente.

El nombre completo de una clase incluye como prefijo el paquete al que pertenece. Por tanto, en elejemplo 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 nombrecompleto:

mipaquete.miclaseA

En este ejemplo, hemos declarado dos clases dentro de un mismo fichero y ambas se han incluido en elmismo paquete, si bien podríamos haberlas declarado en ficheros distintos pero ambas incluidas en elmismo paquete, lo cual suele ser más habitual en programas con varios ficheros fuente. Por ejemplo:


5/17



• 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 paqueteal 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 entornoCLASSPATH. Esta variable contiene las rutas de búsqueda de las clases que se pueden utilizar desdenuestros programas, incluyendo la ruta de la jerarquía de clases del núcleo del lenguaje Java, ynormalmente 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 cualquierlugar 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.


6/17



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, seutiliza 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 unpaquete (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 paquetea 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 sercargada 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 ennuestro programa hay clases que heredan de algunas de las declaradas en el paquete, podremosacceder 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, elcompilador 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 elpaquete java.lang, que son importados automáticamente por el JDK y que por tanto no es necesario

importar explícitamente.


7/17



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 interactuandoentre sí. El código de estas clases puede pertenecer a distintos paquetes y no tiene porqué estar ubicadoen 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, disponede una lista de directorios en los que se encuentran estos comandos. Esta lista se almacena en lavariable de entorno PATH que, por ejemplo, contiene los directorios /bin, /usr/bin, /usr/sbin, etc. en el casode un sistema Linux. Esa es la función de la variable de entorno CLASSPATH para la búsqueda de clasesJava.

La variable CLASSPATH contiene una lista de localizaciones (directorios o rutas de ficheros JAR) dondese 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 configurarpor 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 paraque apunte al directorio anterior a donde comienza una estructura de directorios de un paquete quequeremos 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 delsistema.

4.2 Ficheros JAR

Si bien no están directamente relacionados con el concepto de paquetes en Java, desde la versión 1.1del lenguaje es muy común el empleo de ficheros JAR (Java Archives) para el intercambio de clasesentre programadores o bien para la extensión del API de Java con clases avanzadas, por lo que veremosen 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, queemplea el comúnmente conocido formato ZIP. El contenido típico de un fichero JAR son las clases yrecursos adicionales (imágenes, archivos de texto, ayuda…) asociados con applets o aplicaciones. Laextensió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 seejecuta en un navegador), tenía que realizar tantas conexiones contra el servidor como ficheros (sincomprimir) tuviera la aplicación en cuestión. Esto provocaba que muchos programadores trataran deescribir sus aplicaciones incluyendo todo el código en una única clase, con la consiguiente complejidadpara entender y actualizar dicho fichero fuente.


8/17



Con la llegada del formato JAR, todos los archivos de un applet pueden agruparse en un único fichero, deforma que sólo es necesaria una petición al servidor y, además, como el fichero está comprimido, latransferencia 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 losprogramas que contienen y su origen.

• Portabilidad: no sólo porque los contenidos de un JAR son multiplataforma, sino porqueel manejo de los mismos (comando jar, entre otros) es una parte estándar del núcleo dela API de Java.

• Extensibilidad: los ficheros JAR permiten añadir funcionalidades al núcleo de Java (obien a nuestras aplicaciones), mediante el empaquetado de extensiones. Por ejemplo, elpaquete javax.swing, que veremos en el capítulo 12, se incorporaba a las versionesantiguas de Java como una extensión en un fichero JAR.

• Sellado: opcionalmente se puede obligar a que los paquetes incluidos en un fichero JARexijan 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, eninglé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. Algunasde las opciones más comunes son:

c Crear un archivo nuevo o vacío.

t Listar la tabla de contenidos.

x Extraer todos los archivos.

x fichero Extraer el fichero indicado.

f Indica el nombre del fichero. En caso de no indicarlo, laentrada (o salida) empleadas serán las estándar.

v Generar una salida que describa lo que va haciendo elcomando jar.

0 (cero) Almacenar archivos, sin comprimir. Se emplea para crearficheros JAR que puedan ponerse en el CLASSPATH

M 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 todossus subdirectorios, y se mantiene la información acerca de las rutas (también se puede omitir con laopción C).

Por ejemplo, el comando siguiente:

jar cvf miEjemploJar.jar *.class


9/17



Genera un fichero de nombre miEjemploJar.jar que contendrá todos los archivos de clases del directorioactual 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 permiteque los ficheros JAR soporten el firmado digital, el control de versiones y otras funcionalidades que yahemos comentado. Se trata de un fichero especial, que contiene información (nombres, rutas de acceso yfirmas digitales) sobre los archivos ‘empaquetados’, por ejemplo:

Manifest-Version: 1.0

Name: java/math/BigDecimal.classSHA1-Digest: TD1GZt8G11dXY2p4olSZPc5Rj64=MD5-Digest: z6z8xPj2AW/Q9AkRSPF0cg==

Name: java/math/BigInteger.classSHA1-Digest: oBmrvIkBnSxdNZzPh5iLyF0S+bE=MD5-Digest: wFymhDKjNreNZ4AzDWWg1Q==

Cocoon-Libs: avalon-excalibur-4.1.jar commons-httpclient-20011012.jar commons-collections-1.0.jar xml-apis.jarxercesImpl-2.0.0.jarCocoon-Lib-avalon-excalibur-4_1_jar: 1017127213000Cocoon-Lib-commons-httpclient-20011012_jar: 1017127213000Cocoon-Lib-commons-collections-1_0_jar: 1017127214000Cocoon-Lib-xml-apis_jar: 1017127214000Cocoon-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 delos directorios classes, sonido e imagen. La información ofrecida al indicar la opción v sería algo similar alo siguiente:

adding: classes/claseA.class (in=3825) (out=2222) (deflated41%)adding: sonido/ (in=0) (out=0) (stored 0%)adding: sonido/be.au (in=4032) (out=3572) (deflated 11%)adding: sonido/di.au (in=2566) (out=2055) (deflated 19%)adding: sonido/ren.au (in=6558) (out=4401) (deflated 32%)adding: sonido/ya1.au (in=7834) (out=6985) (deflated 10%)

adding: sonidoo/ya2.au (in=7463) (out=4607) (deflated 38%)adding: imagenes/ (in=0) (out=0) (stored 0%)adding: imagenes/cruz.gif (in=157) (out=160) (deflated -1%)adding: 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 dedirectorios que tenían en el archivo. Si no hubiésemos indicado el archivo a extraer, el comando loshabría extraído todos:

jar xf miOtroEjemploJar.jar


10/17



Finalmente, una vez visto cómo empaquetar y extraer archivos de un fichero JAR, vamos a ver cómo seutilizan 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 setrate: un applet ejecutable desde un navegador, una aplicación independiente o una extensión o driverpara incorporar a nuestros programas. Cada una de estas opciones tiene sus particularidades, pero yahemos visto que la opción O permite crear ficheros JAR sin comprimir, de forma que podemos dejarlos enel 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 sobrecómo utilizarlo: la ruta donde hay que dejar los ficheros (normalmente en el mismo directorio que laaplicación que va a hacer uso de ellos o bien en alguno de los directorios indicados por la variableCLASSPATH), si es necesario realizar alguna configuración del sistema, cómo invocar las clases oaplicaciones, etc. Por ello, la mejor recomendación para utilizar código distribuido de esta forma (comopara cualquier otra aplicación software) es que se lea bien la documentación que lo acompaña en cadacaso, y que suele estar contenida en ficheros simples de texto (README, Howto, Version).


11/17



5 EL API DE JAVA (JDK API O NÚCLEO DEJAVA). PAQUETES DE JAVA

El núcleo del lenguaje Java proporciona una serie de paquetes que incluyen ventanas, utilidades, unsistema de entrada/salida general, herramientas y comunicaciones. Los paquetes Java que se incluyenson java.applet, java.awt, java.io, java.lang, java.net, java.util. Vamos a describir cada uno de ellosbrevemente 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 (GraphicUser 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 enJava 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 conun buffer intermedio.

• BufferedOutputStream: implementa los métodos para escribir en un stream a través de unbuffer.

• 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 accesoaleatorio.

• StreamTokenizer : esta clase recibe un stream de entrada y lo divide (parsea) en diversospedazos (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, quepuede utilizarse para construir un string.


12/17



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 heredanimplí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ónmultiproceso (en Java, multi-hilo), es decir, la posibilidad de que un programa realice variasacciones 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 unainstancia de Class para cada clase cargada.

5.4.1 La clase Object

Ya hemos comentado que la clase estándar Object es la superclase de todas las demás, por lo que todoslos objetos tendrán un conjunto común de métodos, heredados de esta clase y, además, una referencia aeste 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 decadena de caracteres. devuelve una representación en forma de cadena de caracteres delobjeto. 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 delobjeto. Sólo pueden duplicarse aquellas clases que implementan la interfaz cloneable, sino sedevolverá 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 ( ) – sonmé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 contodos 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.


13/17



5.6 java.util

Este paquete es una miscelánea de clases útiles para muchas cosas en programación, como estructurasde 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 decaracteres de separación).

5.7 Otros paquetes

A continuación, se describen brevemente otros paquetes del API de Java, no tan básicos como losanteriores

• java.beans: define componentes software utilizables en cualquier aplicación.

• java.math: paquete de utilidades matemáticas. Dispone de algunas funciones matemáticasadicionales, fundamentalmente la gestión de números enteros y reales muy grandes (demagnitud 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, recorridode 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 enseis á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 dedatos 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 APIcompleto. Contiene la funcionalidad mínima (java.lang, java.util y parte de java.io) y una serie deextensiones 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 redcorporativa.


14/17



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 bienconsultar directamente la ayuda del API de cada clase para proponernos métodos que podamos utilizaren 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 omenos sencillo (ya que sino podría resultar más complejo aprender a manejarlo que dominar el propiolenguaje 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 quedesconocemos.

En general, podremos acceder a la ayuda del JDK que tengamos instalado enC:\\docs\api\index.html

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 laposibilidad 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.


15/17



• Parte derecha: consta de un único frame en el que aparecerá la ayuda acerca del elementoseleccionado. En la parte superior del mismo, disponemos de un menú para ver un índicealfabético (index), el árbol de la jerarquía (Tree), las clases deprecadas (Deprecated) y otra seriede funcionalidades. Más abajo, en caso de haber consultado una clase, veremos su jerarquía declases, una breve explicación de su funcionamiento, sus constructores, un resumen de losmétodos que contiene (propios y heredados) y cada uno de éstos explicados en detalle. Tambiénse suele disponer de ejemplos ilustrativos del funcionamiento de alguno de los métodos.


16/17



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( ), cuyospará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 laaltura 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 claseEspacio debe sumar los volúmenes totales de todas las instancias de sus subclases (no se debeinstanciar 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 vancreando, así como el volumen total. La clase testEspacio debe hacer uso del paquete figura para

realizar estas operaciones.


17/17


Java Introducción a la programación 17

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

Documents

Paquetes X