Paquetes Java

viernes, 23 de marzo de 2007

Claudia Celis - Paquetes de Java

PAQUETES
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
Import
Los paquetes de clases se cargan con la palabra clave import, especificando el nombre del paquete como ruta y nombre de clase (es lo mismo que #include de C/C++). Se pueden cargar varias clases utilizando un asterisco.
import java.Date;
import java.awt.*;
Si un fichero fuente Java no contiene ningún package, se coloca en el paquete por defecto sin nombre. Es decir, en el mismo directorio que el fichero fuente, y la clase puede ser cargada con la sentencia import:
import MiClase;
Paquetes de Java
El lenguaje Java proporciona una serie de paquetes que incluyen ventanas, utilidades, un sistema de entrada/salida general, herramientas y comunicaciones. En la versión actual del JDK, los paquetes Java que se incluyen son:
java.applet
Este paquete contiene clases diseñadas para usar con applets. Hay una clase Applet y tres interfaces: AppletContext, AppletStub y AudioClip.
java.awt
El paquete Abstract Windowing Toolkit (awt) contiene clases para generar widgets y componentes GUI (Interfaz Gráfico de Usuario). Incluye las clases Button, Checkbox, Choice, Component, Graphics, Menu, Panel, TextArea y TextField.
java.io
El paquete de entrada/salida contiene las clases de acceso a ficheros: FileInputStream y FileOutputStream.
java.lang
Este paquete incluye las clases del lenguaje Java propiamente dicho: Object, Thread, Exception, System, Integer, Float, Math, String, etc.
java.net
Este paquete da soporte a las conexiones del protocolo TCP/IP y, además, incluye las clases Socket, URL y URLConnection.
java.util
Este paquete es una miscelánea de clases útiles para muchas cosas en programación. Se incluyen, entre otras, Date (fecha), Dictionary (diccionario), Random (números aleatorios) y Stack (pila FIFO).

La jerarquía de clases que describen las figuras planas

Consideremos las figuras planas cerradas como el rectángulo, y el círculo. Tales figuras comparten características comunes como es la posición de la figura, de su centro, y el área de la figura, aunque el procedimiento para calcular dicha área sea completamente distinto. Podemos por tanto, diseñar una jerarquía de clases, tal que la clase base denominada Figura, tenga las características comunes y cada clase derivada las específicas. La relación jerárquica se muestra en la figura
La clase Figura es la que contiene las características comunes a dichas figuras concretas por tanto, no tiene forma ni tiene área. Esto lo expresamos declarando Figura como una clase abstracta, declarando la función miembro area abstract.
Las clases abstractas solamente se pueden usar como clases base para otras clases. No se pueden crear objetos pertenecientes a una clase abstracta. Sin embargo, se pueden declarar variables de dichas clases.
En el juego del ajedrez podemos definir una clase base denominada Pieza, con las características comunes a todas las piezas, como es su posición en el tablero, y derivar de ella las características específicas de cada pieza particular. Así pues, la clase Pieza será una clase abstracta con una función abstract denominada mover, y cada tipo de pieza definirá dicha función de acuerdo a las reglas de su movimiento sobre el tablero.
La clase Figura
La definición de la clase abstracta Figura, contiene la posición x e y de la figura particular, de su centro, y la función area, que se va a definir en las clases derivadas para calcular el área de cada figura en particular.
public abstract class Figura { protected int x; protected int y; public Figura(int x, int y) { this.x=x; this.y=y; } public abstract double area();}
La clase Rectangulo
Las clases derivadas heredan los miembros dato x e y de la clase base, y definen la función area, declarada abstract en la clase base Figura, ya que cada figura particular tiene una fórmula distinta para calcular su área. Por ejemplo, la clase derivada Rectangulo, tiene como datos, aparte de su posición (x, y) en el plano, sus dimensiones, es decir, su anchura ancho y altura alto.
class Rectangulo extends Figura{ protected double ancho, alto; public Rectangulo(int x, int y, double ancho, double alto){ super(x,y); this.ancho=ancho; this.alto=alto; } public double area(){ return ancho*alto; }}
La primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base, para ello se emplea la palabra reservada super. El constructor de la clase derivada llama al constructor de la clase base y le pasa las coordenadas del punto x e y. Después inicializa sus miembros dato ancho y alto.
En la definición de la función area, se calcula el área del rectángulo como producto de la anchura por la altura, y se devuelve el resultado
La clase Circulo
class Circulo extends Figura{ protected double radio; public Circulo(int x, int y, double radio){ super(x,y); this.radio=radio; } public double area(){ return Math.PI*radio*radio; }}
Como vemos, la primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base empleando la palabara reservada super. Posteriormente, se inicializa el miembro dato radio, de la clase derivada Circulo.
En la definición de la función area, se calcula el área del círculo mediante la conocida fórmula p*r2, o bien p*r*r. La constante Math.PI es una aproximación decimal del número irracional p.

Uso de la jerarquía de clases
Creamos un objeto c de la clase Circulo situado en el punto (0, 0) y de 5.5 unidades de radio. Calculamos y mostramos el valor de su área. Circulo c=new Circulo(0, 0, 5.5); System.out.println("Area del círculo "+c.area());
Creamos un objeto r de la clase Rectangulo situado en el punto (0, 0) y de dimensiones 5.5 de anchura y 2 unidades de largo. Calculamos y mostramos el valor de su área. Rectangulo r=new Rectangulo(0, 0, 5.5, 2.0); System.out.println("Area del rectángulo "+r.area());
Veamos ahora, una forma alternativa, guardamos el valor devuelto por new al crear objetos de las clases derivadas en una variable f del tipo Figura (clase base). Figura f=new Circulo(0, 0, 5.5); System.out.println("Area del círculo "+f.area()); f=new Rectangulo(0, 0, 5.5, 2.0); System.out.println("Area del rectángulo "+f.area());

Enlace dinámico
En el lenguaje C, los identificadores de la función están asociados siempre a direcciones físicas antes de la ejecución del programa, esto se conoce como enlace temprano o estático. Ahora bien, el lenguaje C++ y Java permiten decidir a que función llamar en tiempo de ejecución, esto se conoce como enlace tardío o dinámico. Vamos a ver un ejemplo de ello.
Podemos crear un array de la clase base Figura y guardar en sus elementos los valores devueltos por new al crear objetos de las clases derivadas. Figura[] fig=new Figura[4]; fig[0]=new Rectangulo(0,0, 5.0, 7.0); fig[1]=new Circulo(0,0, 5.0); fig[2]=new Circulo(0, 0, 7.0); fig[3]=new Rectangulo(0,0, 4.0, 6.0);
La sentencia fig[i].area();
¿a qué función area llamará?. La respuesta será, según sea el índice i. Si i es cero, el primer elemento del array guarda una referencia a un objeto de la clase Rectangulo, luego llamará a la función miembro area de Rectangulo. Si i es uno, el segundo elemento del array guarda una referencia un objeto de la clase Circulo, luego llamará también a la función area de Circulo, y así sucesivamente. Pero podemos introducir el valor del índice i, a través del teclado, o seleccionando un control en un applet, en el momento en el que se ejecuta el programa. Luego, la decisión sobre qué función area se va a llamar se retrasa hasta el tiempo de ejecución.

El polimorfismo en acción
Supongamos que deseamos saber la figura que tiene mayor área independientemente de su forma. Primero, programamos una función que halle el mayor de varios números reales positivos.double valorMayor(double[] x){ double mayor=0.0; for (int i=0; imayor){ mayor=x[i]; } return mayor;}
Ahora, la llamada a la función valorMayor double numeros[]={3.2, 3.0, 5.4, 1.2}; System.out.println("El valor mayor es "+valorMayor(numeros));
La función figuraMayor que compara el área de figuras planas es semejante a la función valorMayor anteriormente definida, se le pasa el array de objetos de la clase base Figura. La función devuelve una referencia al objeto cuya área es la mayor.
static Figura figuraMayor(Figura[] figuras){ Figura mFigura=null; double areaMayor=0.0; for(int i=0; iareaMayor){ areaMayor=figuras[i].area(); mFigura=figuras[i]; } } return mFigura; }
La clave de la definición de la función está en las líneas if(figuras[i].area()>areaMayor){ areaMayor=figuras[i].area(); mFigura=figuras[i]; }
En la primera línea, se llama a la versión correcta de la función area dependiendo de la referencia al tipo de objeto que guarda el elemento figuras[i] del array. En areaMayor se guarda el valor mayor de las áreas calculadas, y en mFigura, la figura cuya área es la mayor.
La principal ventaja de la definición de esta función estriba en que la función figuraMayor está definida en términos de variable figuras de la clase base Figura, por tanto, trabaja no solamente para una colección de círculos y rectángulos, sino también para cualquier otra figura derivada de la clase base Figura. Así si se deriva Triangulo de Figura, y se añade a la jerarquía de clases, la función figuraMayor podrá manejar objetos de dicha clase, sin modificar para nada el código de la misma.
Veamos ahora la llamada a la función figuraMayor Figura[] fig=new Figura[4]; fig[0]=new Rectangulo(0,0, 5.0, 7.0); fig[1]=new Circulo(0,0, 5.0); fig[2]=new Circulo(0, 0, 7.0); fig[3]=new Rectangulo(0,0, 4.0, 6.0); Figura fMayor=figuraMayor(fig); System.out.println("El área mayor es "+fMayor.area());
Pasamos el array fig a la función figuraMayor, el valor que retorna lo guardamos en fMayor. Para conocer el valor del área, desde fMayor se llamará a la función miembro area. Se llamará a la versión correcta dependiendo de la referencia al tipo de objeto que guarde por fMayor. Si fMayor guarda una referencia a un objeto de la clase Circulo, llamará a la función area definida en dicha clase. Si fMayor guarda una referencia a un objeto de la clase Rectangulo, llamará a la función area definida en dicha clase, y así sucesivamente.
La combinación de herencia y enlace dinámico se denomina polimorfismo. El polimorfismo es, por tanto, la técnica que permite pasar un objeto de una clase derivada a funciones que conocen el objeto solamente por su clase base.

Claudia Celis Cod. 221183104

Paquetes y Jerarquías de Java / Andres Combariza

Paquetes

Para explicar el tema de los paquetes imaginarse una ciudad en la cual hay varios bloques de apartamentos propiedad de una única empresa inmobiliaria. Esta empresa dispone además de comercios, zonas de recreo y almacenes. Se puede pensar en la empresa como una lista de referencias a cada una de sus propiedades; es decir, la inmobiliaria sabe exactamente donde está un apartamento determinado y puede hacer uso de él en el momento en que lo necesite.
Si ahora se mira lo anterior en términos de Java, la empresa inmobiliaria es el paquete. Los paquetes agrupan a librerías de clases, como las librerías que contienen información sobre distintas propiedades comerciales. Un paquete será, pues, la mayor unidad lógica de objetos en Java.
Los paquetes se utilizan en Java de forma similar a como se utilizan las librerías en C++, para agrupar funciones y clases, sólo que en Java agrupan diferentes clases y/o interfaces. En ellos las clases son únicas, comparadas con las de otros paquetes, y además proporcionan un método de control de acceso. Los paquetes también proporcionan una forma de ocultar clases, evitando que otros programas o paquetes accedan a clases que son de uso exclusivo de una aplicación determinada.
Declaración de Paquetes
Los paquetes se declaran utilizando la palabra package seguida del nombre del paquete. Esto debe estar al comienzo del fichero fuente, en concreto, debe ser la primera sentencia ejecutable del código Java, excluyendo, claro está, los comentarios y espacios en blanco. Por ejemplo:
package mamiferos;
class Ballena {
. . .
}
En este ejemplo, el nombre del paquete es mamiferos. La clase Ballena se considera como parte del paquete. La inclusión de nuevas clases en el paquete es muy sencilla, ya que basta con colocar la misma sentencia al comienzo de los ficheros que contengan la declaración de las clases. Como cada clase se debe colocar en un fichero separado, cada uno de los ficheros que contengan clases pertenecientes a un mismo paquete, deben incluir la misma sentencia package, y solamente puede haber una sentencia package por fichero.
Se recuerda que el compilador Java solamente requiere que se coloquen en ficheros separados las clases que se declaren públicas. Las clases no públicas se pueden colocar en el mismo fichero fuente, al igual que las clases anidadas. Aunque es una buena norma de programación que todas las clases se encuentren en un único fichero, la sentencia package colocada el comienzo de un fichero fuente afectará a todas las clases que se declaren en ese fichero.
Java también soporta el concepto de jeraquía de paquetes. Esto es parecido a la jerarquía de directorios de la mayoría de los sitemas operativos. Se consigue especificando múmtiples nombres en la sentencia package, separados por puntos. Por ejemplo, en las sentencias siguientes, la clase Ballena pertenece al paquete mamiferos que cae dentro de la jerarquía del paquete animales.
package animales.mamiferos;
class Ballena {
. . .
}
Esto permite agrupar clases relacionadas en un solo paquete, y agrupar paquetes relacionados en un paquete más grande. Para referenciar a un miembro de otro paquete, se debe colocar el nombre del paquete antes del nombre de la clase. La siguiente sentencia es un ejemplo de llamada al método obtenerNombre() de la clase Ballena que pertenece al subpaquete mamiferos del paquete animales:
animales.mamiferos.Ballena.obtenerNombre();
La analogía con la jerarquía de directorios se ve reforzada por el intérprete Java, ya que éste requiere que los ficheros .class se encuentren físicamente localizados en subdirectorios que coincidan con el nombre del subpaquete. En el ejemplo anterior, si se encontrase en una máquina Unix, la clase Ballena debería estar situada en el camino siguiente:
animales/mamiferos/Ballena.class
Por supuesto, las convenciones en el nombre de los directorios serán diferentes para los distintos sistemas operativos. El compilador Java colocará los ficheros .class en el mismo directorio que se encuentren los ficheros fuentes, por lo que puede ser necesario mover los ficheros .class resultantes de la compilación al directorio adecuado, en el caso de que no se encuentren los fuentes en el lugar correcto del árbol jerárquico. Aunque los ficheros .class también se pueden colocar directamente en el directorio que se desee especificando la opción -d (directorio) a la hora de invocar al compilador. La siguiente línea de comando colocará el fichero resultante de la compilación en el subdirectorio animales/mamiferos/Ballenas, independientemente de cual sea el directorio desde el cual se esté invocando al compilador.
> javac -d animales/mamiferos/Ballena Ballena.java
Todas las clases quedan englobadas dentro de un mismo paquete, si no se especifica explíctamente lo contrario, es decir, aunque no se indique nada, las clases pertenecen a un paquete; ya que, como es normal en Java, lo que no se declara explícitamente, toma valores por defecto. En este caso, hay un paquete sin nombre que agrupa a todos los demás paquetes. Si un paquete no tiene nombre, no es posible para los demás paquetes referenciar a ese paquete, por eso es conveniente colocar todas las clases no triviales en paquetes, para que puedan ser referenciadas posteriormente desde cualquier otro programa.
Acceso a Otros Paquetes
Se decía que se pueden referenciar paquetes precediendo con su nombre la clase que se quiere usar. También se puede emplear la palabra clave import, si se van a colocar múltiples referencias a un mismo paquete, o si el nombre del paquete es muy largo o complicado.
La sentencia import se utiliza para incluir una lista de paquetes en los que buscar una clase determinada, y su sintaxis es:
import nombre_paquete;
Esta sentencia, o grupo de ellas, deben aparecer antes de cualquier declaración de clase en el código fuente. Por ejemplo:
import animales.mamiferos.Ballena;
En este ejemplo, todos los miembros (variables, métodos) de la clase Ballena están accesibles especificando simplemente su nombre, sin tener que precederlo del nombre completo del paquete.
Esta forma de abreviar tienes sus ventajas y sus desventajas. La ventaja principal es que el código no se vuelve demasiado difícil de leer y además es más rápido de teclear. La desventaja fundamental es que resulta más complicado el saber exactamente a qué paquete pertenece un determinado miembro; y esto es especialmente complicado cuando hay muchos paquetes importados.
En la sentencia import también se admite la presencia del carácter *, asterisco. Cuando se emplea, se indica que toda la jerarquía de clases localizada a partir del punto en que se encuentre, debe ser importada, en lugar de indicar solamente una determinada clase. Por ejemplo, la siguiente sentencia indicaría que todas la clases del subpaquete animales.mamiferos, deben ser importadas:
import animales.mamiferos.*;
Esta es una forma simple y sencilla de tener acceso a todas las clases de un determinado paquete. Aunque el uso del asterisco debe hacerse con cautela, porque al ya de por sí lento compilador, si se pone un asterisco, se cargarán todos los paquetes, lo que hará todavía más lenta la compilación. No obstante, el asterisco no tiene impacto alguno a la hora de la ejecución, solamente en tiempo de compilación.
La sentencia import se utiliza en casi todos los ejemplos del Tutorial, fundamentalmente para acceder a las distintas partes del API de Java. Por defecto, el conjunto de clases bajo java.lang.* se importan siempre; las otras librerías deben ser importadas explícitamente. Por ejemplo, las siguientes líneas de código premiten el acceso a las clases correspondientes a las librerías de manipulacion de imágenes y gráficos:
import java.awt.Image;
import java.awt.Graphics;
Nomenclatura de Paquetes
Los paquetes pueden nombrarse de cualquier forma que siga el esquema de nomenclatura de Java. Por convenio, no obstante, los nombres de paquetes comienzan por una letra minúscula para hacer más sencillo el reconocimiento de paquetes y clases, cuando se tiene una referencia explícita a una clase. Esto es porque los nombres de las clases, también por convenio, empiezan con una letra mayúscula. Por ejemplo, cuando se usa el convenio citado, es obvio que tanto animales como mamiferos son paquetes y que Ballena es una clase. Cuanquier cosa que siga al nombre de la clase es un miembro de esa clase:
animales.mamiferos.Ballena.obtenerNombre();
Java sigue este convenio en todo el API. Por ejemplo, el método System.out.println() que tanto se ha utilizado sigue esta nomenclatura. El nombre del paquete no se declara explícitamente porque java.lang.* siempre es importado implícitamente. System es el nombre de la clase perteneciente al paquete java.lang y está capitalizado. El nombre completo del método es:
java.lang.System.out.println();
Cada nombre de paquete ha de ser único, para que el uso de paquetes sea realmente efectivo. Los conflictos de nombres pueden causar problemas a la hora de la ejecución en caso de duplicidad, ya que los ficheros de clases podrían saltar de uno a otro directorio. En caso de proyectos pequeños no es difícil mantener una unicidad de nombres, pero en caso de grandes proyectos; o se sigue una norma desde el comienzo del proyecto, o éste se convertirá en un auténtico caos.
No hay ninguna organización en Internet que controle esta nomenclatura, y muchas de las aplicaciones Java corren sobre Web. Hay que tener presente que muchos servidores Web incluyen applets de múltiples orígenes, con lo cual parece poco menos que imposible el evitar que alguien duplique nombres.
Javasoft ha reconocido este problema ya en una fase avanzada de su desarrollo, así que han indicado una convención para asegurar que los nombres de los paquetes sean únicos, basándose en los dominios, colocándolos al revés. Es decir, un dominio del tipo miempresa.com, debería colocar delante de todos sus paquetes el prefijo com.miempresa. Esto resolvería el problema de la nomenclatura, ya que los desarrolladores podrían controlar sus propios paquetes y, además, se generaría una estructura jerárquica de paquetes muy limpia. De hecho, el paquete Swing en la versión beta 3 del JDK 1.2 se situó bajo el árbol java.awt, lo cual sugería que las clases Swing dependían del AWT, cuando es un paquete autosuficiente y que no tiene mucho que ver con el AWT, así que Javasoft dió marcha atrás en su nomenclatura y colocó el paquete en su situación actual com.java.Swing.
Como norma y resumen de todo lo dicho, a la hora de crear un paquete hay que tener presente una serie de ideas:
La palabra clave package debe ser la primera sentencia que aparezca en el fichero, exceptuando, claro está, los espacios en blanco y comentarios
Es aconsejable que todas las clases que vayan a ser incluidas en el paquete se encuentren en el mismo directorio. Como se ha visto, esta recomendación se la puede uno saltar a la torera, pero se corre el riesgo de que aparezcan determinados problemas difíciles de resolver a la hora de compilar, en el supuesto caso de que no se hile muy fino
Ante todo, recordar que en un fichero únicamente puede existir, como máximo, una clase con el especificador de acceso public, debiendo coincidir el nombre del fichero con el nombre de la clase
Variable de Entorno CLASSPATH
El intérprete Java debe encontrar todas las clases referenciadas cuando se ejecuta una aplicación Java. Por defecto, Java busca en el árbol de instalación del Java esas librerías. En el Tutorial de Java de Sun, se indica que "los ficheros .class del paquete java.util están en un directorio llamado util de un directorio java, situado en algún lugar apuntado por CLASSPATH".
CLASSPATH es una variable de entorno que indica al sistema dónde debe buscar los ficheros .class que necesite. Sin embargo, lo que dice el Tutorial de Java de Sun, normalmente no es así, lo cual puede ocasionar confusión. Cuando se utiliza el JDK, no existe el directorio que se indica.
La no existencia se debe a que Java tiene la capacidad de buscar ficheros comprimidos que utilicen la tecnología zip. Esto redunda en un gran ahorro de espacio en disco y además, mantiene la estructura de directorios en el fichero comprimido. Por tanto, se podría parafrasear lo indicado por Sun escribiendo que "en algún lugar del disco, se encontrará un fichero comprimido (zip) que contiene una gran cantidad de ficheros .class. Antes de haber sido comprimidos, los ficheros .class del paquete java.util estaban situados en un directorio llamado util de un directorio java. Estos ficheros, junto con sus estructura se almacenar en el fichero comprimido que debe encontrarse en algún lugar apuntado por CLASSPATH".
CLASSPATH contiene la lista de directorios en los que se debe buscar los árboles jerárquicos de librerías de clases. La sintaxis de esta variable de entorno varía dependiendo del sistema operativo que se esté utilizando; en sistemas Unix, contiene una lista de directorios separados por : (dos puntos), mientras que en sistemas Windows, la lista de directorios está separada por ; (punto y coma). La sentencia siguiente muestra un ejemplo de esta variables en un sistema Unix:
CLASSPATH=/home/users/afq/java/classes:/opt/apps/Java
indicando al intérprete Java que busque en los directorios /home/users/afq/java/classes y /opt/apps/Java las librerías de clases.
Paquetes de Java
El lenguaje Java proporciona una serie de paquetes que incluyen ventanas, utilidades, un sistema de entrada/salida general, herramientas y comunicaciones. En la versión actual del JDK, algunos de los paquetes Java que se incluyen son los que se muestran a continuación, que no es una lista exhaustiva, sino para que el lector pueda tener una idea aproximada de lo que contienen los paquetes más importantes que proporciona el JDK de Sun. Posteriormente, en el desarrollo de otros apartados del Tutorial, se introducirán otros paquetes que también forman parte del JDK y que, incorporan características a Java que hacen de él un lenguaje mucho más potente y versátil, como son los paquetes Java2D o Swing, que han entrado a formar parte oficial del JDK en la versión JDK 1.2.
java.applet
Este paquete contiene clases diseñadas para usar con applets. Hay la clase Applet y tres interfaces: AppletContext, AppletStub y AudioClip.
java.awt
El paquete Abstract Windowing Toolkit (awt) contiene clases para generar widgets y componentes GUI (Interfaz Gráfico de Usuario), de manipulación de imágenes, impresión, fuentes de caracteres, cursores, etc.. Incluye las clases Button, Checkbox, Choice, Component, Graphics, Menu, Panel, TextArea, TextField...
java.io
El paquete de entrada/salida contiene las clases de acceso a ficheros, de filtrado de información, serialización de objetos, etc.: FileInputStream, FileOutputStream, FileReader, FileWriter. También contiene los interfaces que facilitan la utilización de las clases: DataInput, DataOutput, Externalizable, FileFilter, FilenameFilter, ObjectInput, ObjectOutput, Serializable...
java.lang
Este paquete incluye las clases del lenguaje Java propiamente dicho: Object, Thread, Exception, System, Integer, Float, Math, String, Package, Process, Runtime, etc.
java.net
Este paquete da soporte a las conexiones del protocolo TCP/IP y, además, incluye las clases Socket, URL y URLConnection.
java.sql
Este paquete incluye todos los interfaces que dan acceso a Bases de Datos a través de JDBC, Java DataBase Connectivity, como son: Array, Blob, Connection, Driver, Ref, ResultSet, SQLData, SQLInput, SQLOutput, Statement, Struct; y algunas clases específicas: Date, DriveManager, Time, Types...
java.util
Este paquete es una miscelánea de clases útiles para muchas cosas en programación: estructuras de datos, fechas, horas, internacionalización,etc. Se incluyen, entre otras, Date (fecha), Dictionary (diccionario), List (lista), Map (mapa), Random (números aleatorios) y Stack (pila FIFO). Dentro de este paquete, hay tres paquetes muy interesantes: java.util.jar, que proporciona clases para leer y crear ficheros JAR; java.util.mime, que proporciona clases para manipular tipos MIME, Multipurpose Internet Mail Extension (RFC 2045, RFC 2046) y java.util.zip, que proporciona clases para comprimir, descomprimir, calcular checksums de datos, etc. con los formatos estándar ZIP y GZIP.

La jerarquía de clases que describen las figuras planas

Andres Combariza Ibarra Cod. 221184104

Paquetes y jererquias en Java

Paquetes de Java.

¿Qué es un package?

Un package es una agrupación de clases.

Los nombres de los packages se suelen escribir con minúsculas, para distinguirlos de las clases, que empiezan por mayúscula. El nombre de un package puede constar de varios nombres unidos por puntos (los propios packages de Java siguen esta norma, como por ejemplo java.awt.event).

Prácticamente son bibliotecas a las que el usuario puede acceder y que ofrecen varias funciones.

Los usuarios pueden también crear paquetes, que contengan todas las clases que ha definido para poner en marcha algunas funciones que luego usará en otros programas.

package pkgName; que debe ser la primera sentencia del fichero sin contar comentarios y líneas en blanco.

Las clases de un package se almacenan en un directorio con el mismo nombre largo (path) que el package.

Por ejemplo, la clase, es.ceit.jgjalon.infor2.ordenar.QuickSort.class debería estar en el directorio,
CLASSPATH\es\ceit\jgjalon\infor2\ordenar\QuickSort.class, donde CLASSPATH es una variable de entorno del PC que establece la posición absoluta de los directorios en los que hay clases de Java (clases del sistema o de usuario), en este caso la posición del directorio es en los discos locales del ordenador.

Los packages se utilizan con las finalidades siguientes:

1. Para agrupar clases relacionadas.

2. Para evitar conflictos de nombres (se recuerda que el dominio de nombres de Java es la Internet). En caso de conflicto de nombres entre clases importadas, el compilador obliga a cualificar en el código los nombres de dichas clases con el nombre del package.

3. Para ayudar en el control de la accesibilidad de clases y miembros.

¿Cómo funcionan los packages?

Con la sentencia import packname; se puede evitar tener que utilizar nombres muy largos, al mismo tiempo que se evitan los conflictos entre nombres. Si a pesar de todo hay conflicto entre nombres de clases, Java da un error y obliga a utilizar los nombres de las clases cualificados con el nombre del package.

El importar un package no hace que se carguen todas las clases del package: sólo se cargarán las clases public que se vayan a utilizar. Al importar un package no se importan los sub-packages.

Éstos deben ser importados explícitamente, pues en realidad son packages distintos. Por ejemplo, al importar java.awt no se importa java.awt.event.Es posible guardar en jerarquías de directorios diferentes los ficheros *.class y *.java, con objeto por ejemplo de no mostrar la situación del código fuente.

Los packages hacen referencia a los ficheros compilados *.class.

Esta es la gran ventaja de Java, el número de clases ya establecidas que realizan variadas tareas, y es también la parte que sigue creciendo más y más, y que sigue poniéndose al día con las nuevas versiones de.

Los paquetes de Java son tantos que sólo hablare de dos es decir, los que nos sirven para interfaces gráficas y apliques.

El núcleo del lenguaje Java contiene sólo las palabras claves para la construcción de las clases, los comentarios, las construcciones normales en if, switch, while, do-while, for, etiquetas, break, continue e return (falta el goto).

Todo lo demás está contenido en los paquetes informáticos del lenguaje, incluidas las normales primitivas de Entrada y de Salida.

Jerarquía de Clases en Java

Figuras planas

Las clases abstractas solamente se pueden usar como clases base para otras clases. No se pueden crear objetos pertenecientes a una clase abstracta. Sin embargo, se pueden declarar variables de dichas clases.

En el juego del ajedrez podemos definir una clase base denominada Pieza, con las características comunes a todas las piezas, como es su posición en el tablero, y derivar de ella las características específicas de cada pieza particular.

Así pues, la clase Pieza será una clase abstracta con una función abstract denominada mover, y cada tipo de pieza definirá dicha función de acuerdo a las reglas de su movimiento sobre el tablero.

A continuación vemos un ejemplo de una jerarquía de clases de una cuenta bancaria:

CYBERGRAFIA

http://www.htmlpoint.com/guidajava/java_03.htmhttp://
http://www.htmlpoint.com/guidajava/java_03.htmhttp://
http://www.geocities.com/CollegePark/Quad/8901/cap05.htmhttp://
www.geocities.com/CollegePark/Quad/8901/cap05.htmhttp://
http://www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/herencia.htmhttp://
www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/herencia.htmhttp://
www.sc.ehu.es/sbweb/fisica/cursoJava/fundamentos/clases1/paquetes.htm
http://www.monografias.com/trabajos16/java/java.shtmlhttp://
http://www.monografias.com/trabajos16/java/java.shtmlhttp://
http://www.htmlpoint.com/guidajava/java_14.htmhttp://
www.htmlpoint.com/guidajava/java_14.htmhttp://
www.lab.dit.upm.es/~lprg/material/apuntes/packages/packages.htm

Java SE - Paquetes de Proposito General

Java SE - Paquetes de Propósito General

Karen Viviana Guevara Oyuela

Código: 221273103

VII semestre Ingeniería de Sistemas

Java Platform, Standard Edition o Java SE (conocido anteriormente hasta la versión 5.0 como Plataforma Java 2, Standard Edition o J2SE), es una colección de APIs del lenguaje de programación Java utiles para muchos programas de la Plataforma Java. La Plataforma Java 2, Enterprise Edition incluye todas las clases en el Java SE, además de algunas de las cuales son útiles para programas que se ejecutan en servidores sobre workstations. Comenzando con la versión J2SE 1.4 (Merlin), la plataforma Java SE ha sido desarrollada bajo la supervisión del Java Community Process. JSR 59 la especificación para J2SE 1.4 y JSR 176 especificó J2SE 5.0 (Tiger). En 2006, Java SE 6 (Mustang) está siendo desarrollada bajo el JSR 270.

Lo siguiente son descripciones de algunos de los principales paquetes Java SE. Paquetes de Propósito general

java.lang

El paquete Java java.lang contiene clases fundamentales e interfaces fuertemente relacionadas con el lenguaje y el sistema runtime. Esto incluye las clases raíz que forman la jerarquía de clases, tipos relacionados con la definición del lenguaje, excepciones básicas, funciones matemáticas, Hilos, funciones de seguridad, así como también alguna información sobre el sistema nativo subyacente.

Las principales clases en java.lang son:

Object – la clase que es la raíz de toda la jerarquía de clases.
Enum – la clase base para las clases enumeration (propias de J2SE 5.0).
Class – la clase que es la raíz del sistema de refleccion Java.
Throwable – la clase que es la clase base de la jerarquía de clases de excepciones.
Error, Exception, y RuntimeException – las clases base de cada tipo de excepción.
Thread– la clase que permite operaciones con hilos.
String – la clase para cadenas String y literales.
StringBuffer y StringBuilder – clases para realizar manipulación de strings(StringBuilder como parte de J2SE 5.0).
Comparable – la interfaz que permite comparación genérica y ordenamiento de objetos (como parte de J2SE 1.2).
Iterable – la interfaz que permite iteración genérica usando el bucle for mejorado (como parte J2SE 5.0).
ClassLoader, Process, Runtime,SecurityManager, y System – clases que suministran "operaciones del sistema" que gestionan la enlazado dinamico de clases, creación de procesos externos, investigaciones del entorno del host tales como la hora del día, y refuerzo de políticas de seguridad.
Las clases Math y StrictMath – suministran funciones matemáticas básicas tales como seno, coseno, y raíz cuadrada(StrictMath forma parte de J2SE 1.3).
Las clases wrapper primitivas encapsulan tipos primitivos como objetos.
Las clases exception básicas lanzan excepciones del nivel del lenguaje y otras excepciones comunes.

Las clases de java.lang son importadas automáticamente a cada Fichero Fuente.

java.lang.ref

El paquete es importado automáticamente a cada fichero fuente. El paquete java.lang.ref suministra tipos más flexibles de Referencias que otros disponibles, permitiendo interacción limitada entre la aplicación y la recolección de basura de la Máquina virtual java (JVM) . Es un paquete importante, suficientemente céntrico al lenguaje para que los diseñadores del lenguaje le den un nombre que comience por "java.lang", pero es de propósito especial, y no usado por muchos desarrolladores. Este paquete se añadió en J2SE 1.2.
Java tiene un sistema de referencias más expresivo que la mayoría de los otros lenguajes de programación que la emplean, lo cual permite comportamiento especial para recolección de basura. Una referencia normal en Java se conoce como una referencia fuerte. El paquete java.lang.ref define otros tipos de referencias—referencias soft, weak, y fantasma. Cada tipo de referencia está diseñado para uso específico.

Una SoftReference puede usarse para implementar una cache. Un objeto que no es recuperable por una referencia fuerte (esto es, no es recuperable fuertemente), pero que está referenciado por una referencia soft se llama recuperable softly. Un objeto recuperable softly puede ser recolectado como basura a decisión del recolector de basura. Esto generalmente significa que los objetos recuperables softly solo serán recolectados cuando la memoria libre sea baja, pero también, es la decisión del recolector de basura. Semánticamente, una referencia soft significa "manten este objeto a menos que la memoria se necesite."

Una WeakReference se usa para implementar mapas weak. Un objeto que no es recuperable fuertemente o softly, pero se referencia por una referencia weak que se llamada "recuperable weakely". Un objeto recuperable weakly será recolectado a la basura durante el siguiente ciclo de recolección. Este comportamiento se usa en la clase WeakHashMap. Un mapa weak permite al programador poner pares clave/valor en el mapa y no preocuparse que los objetos tomen memoria cuando la clave ya no sea recuperable en ningún sitio más. Semánticamente, una referencia weak significa "conseguir la liberación de este objeto cuando nada más lo referencia."

Una PhantomReference se usa para referenciar objetos que han sido marcados para recolección de basura y han sido finalizados, pero no han sido aún reclamados. Un objeto que no es recuperable fuertemente, softly o weakly, pero es referenciado por una referencia fantasma se llama recuperable fantasma. Esto permite limpieza más flexible que es posible con el mecanismo de finalización solo. Semánticamente, una referencia fantasma significa "este objeto no se necesita más y ha sido finalizado en preparación a ser recolectado." Cada uno de esos tipos de referencia extienden la clase Reference la cual suministra el método get() para devolver una referencia fuerte al objeto referido (o null si la referencia ha sido aclarada o si el tipo de referencia es fantasma), y el método clear() para limpiar la referencia. java.lang.ref también define la ReferenceQueue de clase, la cual puede usarse en cada aplicación discutida sobre mantener la pista de los objetos que han cambiado el tipo de referencia. Cuando una Reference se crea está registrado opcionalmente con una cola de referencias. La aplicación encuesta la cola de referencias para obtener referencias que han cambiado el estado de alcanzabilidad.

java.lang.reflect

Reflexión (programación) es un componente de la API Java la cual permite al código Java examinar y "reflexionar" sobre los componentes Java en tiempo de ejecución y para usar miembros reflexionados. Las Clases en este paquete, junto con java.lang.Class y java.lang.Package acomodan aplicaciones tales como depuradores, interpretes, inspectores de objetos, navegadores de clases, y servicios tales como Serialización de objetos y JavaBeans que necesitan acceso a miembros públicos del objeto objetivo (basándose en su clase runtime) o a los miembros declarados por una clase dada. Este paquete fue añadido en JDK 1.1.

La Reflexión se usa para instanciar clases e invocar métodos usando sus nombres, un concepto que permite la programación dinámica. Clases, interfaces, métodos, campos, y constructores pueden ser todos descubiertos y usados en tiempo de ejecución. Reflexión se soporta por los metadatos que la JVM posee sobre el programa. Hay dos técnicas básicas involucradas en la reflexión:

1. Descubrimiento: conlleva tomar un objeto o clase y descubrir los miembros, superclases, interfaces implementadas, y después usar posiblemente los elementos descubiertos.

2. Usar por nombre conlleva empezar con el nombre simbólico de un elemento y usar el elemento nombrado.

Descubrimiento

El Descubrimiento normalmente empieza con un objeto y llamando al método Object.getClass() para obtener la clase del objeto. El objeto Class tiene varios métodos para descubrir los contenidos de la clase, por ejemplo:

getMethods() – devuelve un array de objetos Method que representan los métodos publicos de la clase o interface
getConstructors() – devuelve un array de objetos Constructor que representan todos los constructores públicos de la clase
getFields() – devuelve un array de objetos java/lang/reflectField que representan todos los campos públicos de la clase o interface
getClasses() – devuelve un array de objetos Class representando todas las clases e interfaces públicas que son miembros de la clase o interface
getSuperclass() – devuelve el objeto Class que representa la superclase de la clase o interface
getInterfaces() – devuelve un array de objetos Class que representan todas las interfaces que se implementan por la clase o la interface

Usar por nombre

El objeto Class puede obtenerse a través de descubrimiento, usando la clase literal (e.g. MyClass.class) o usando el nombre de la clase( e.g. String) Class.forName("mypackage.MyClass")) ). Con un objeto Class, Method miembro, Constructor, u objetos Field pueden obtenerse usando el nombre simbólico del miembro. Por ejemplo:

java.lang.Class...) getMethod("methodName", Class...) – devuelve el objeto Method que representa el método público con el nombre "methodName" de la clase o interface que acepta los parámetros especificados por los parámetros Class... parameters.
getConstructor(Class...) – devuelve el objeto Constructor que representa el constructor público de la clase que acepta los parámetros especificados por la Class....
String) getField("fieldName") – devuelve el objeto Field que representa el campo público con el nombre "fieldName" de la clase o la interface.

Los Objetos Method, Constructor, y Field pueden usarse para acceder dinámicamente al miembro representado de la clase. Por ejemplo:

Object) Field.get(Object) – devuelve un Object que contiene el valor del campo desde la instancia del objeto pasado a get().
java.lang.Object...) Method.invoke(Object, Object...) – devuelve un Object que contiene el resultado de invocar el método para la instancia del primer parámetro Object pasado a invoke(). Los parámetros Object... restantes son pasados al método.
Constructor.newInstance(Object...) – devuelve la nueva instancia Object invocando al constructor. Los parámetros Object... son pasados al constructor. (Date cuente de que el constructor sin parámetros para una clase puede también ser invocado llamando a newInstance()).

Arrays y proxies

El paquete java.lang.reflect también suministra una clase Array que contiene métodos estáticos para crear y manipular objetos array, y desde J2SE 1.3, una clase Proxy que suministra creación dinámica de clases proxy que implementan las interfaces especificadas.

La implementación de una clase Proxy se suministra por un objeto dado que implementa la interface InvocationHandler. El método invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[]) de InvocationHandler es llamado por cada método invocado en el objeto proxy—el primer parámetro es el objeto proxy, el segundo parámetro es el objeto Method que representa el método desde el que la interface implementó al proxy, y el tercer parámetro es el array de parámetros pasado al método interface. El método invoke() devuelve un resultado Object que contiene el resultado devuelto al código que llamó al método interface proxy.

java.io

El paquete java.io contiene clases que soportan entrada/salida. Las clases del paquete son principalmente streams; sin embargo, se incluye una clase para ficheros de acceso aleatorio. Las clases centrales del paquete son InputStream y OutputStream las cuales son clases abstractas base para leer de y escribir a streams de bytes, respectivamente. Las clases relacionadas Reader y Writer son clases abstractas base para leer de y escribir a streams de caracteres, respectivamente. El paquete también tiene unas pocas clases misceláneas para soportar la interacción con el Sistema de ficheros del computador.

Streams

Las clases stream siguen el patrón decorator extendiendo la subclase base para añadir características a las clases stream. Las Subclases de las clases base stream son nombradas típicamente por uno de los siguientes atributos:

la fuente/destino de los datos del stream
el tipo de los datos escritos a/leidos del stream
procesamiento adicional o filtrado realizado en los datos del stream

Las subclases stream son nombradas usando el patrón naming XxxStreamType donde Xxx es el nombre que describe la característica y StreamType es uno de InputStream, OutputStream, Reader, o Writer.

La siguiente tabla muestra las fuentes/destinos soportados directamente por el paquete java.io:

http://img113.imageshack.us/img113/4184/cuadrofuentedestinoda5.png

Otros paquetes de librería estándar suministran implementaciones de stream para otros destinos, tales como el InputStream devuelto por el método SocketgetInputStream() o la clase Java EE javax/servletServletOutputStream.

El manejo y procesamiento de tipos de datos o filtrado de los datos de stream se realiza a través de filtros de stream. Las clases filter aceptan otros objetos de stream compatibles como parámetro para el constructor y decoran el stream contenido con características adicionales. Los Filtros se crean extendiendo una de las clases base filter FilterInputStream, FilterOutputStream, FilterReader, o FilterWriter.

Las clases Reader y Writer son justamente streams de bytes con procesamiento adicional realizado en el stream de datos para convertir los bytes a caracteres. Utilizan la codificación de caracteres por defecto para la plataforma, la cual desde J2SE 5.0 se representa por el Charset devuelto por el método estático java/nio/charsetCharsetdefaultCharset(). La clase java/ioInputStreamReader convierte un InputStream a un Reader y la clase java/ioOutputStreamWriter convierte un OutputStream a un Writer. Ambas clases tienen constructores que permiten la codificación de caracteres que sea especificada—si no se especifica ninguna codificación entonces se usa la codificación por defecto para la plataforma.

La siguiente tabla muestra los otros procesos y filtros soportados directamente por el paquete java.io. Todas esas clases extienden la clase Filter correspondiente.

http://img252.imageshack.us/img252/5650/operacionnombrezf1.png

Acceso aleatorio

La clase RandomAccessFile soporta lectura y escritura de acceso aleatorio de ficheros. La clase usa un puntero a fichero que representa un byte-offset dentro del fichero para la siguiente operación de lectura o escritura. El puntero a fichero se mueve implícitamente leyendo o escribiendo y explícitamente llamando a los métodos java/ioRandomAccessFileseek(long) o java/ioRandomAccessFileskipBytes(int). La posición actual del puntero de fichero se devuelve por el método java/ioRandomAccessFilegetFilePointer().

Sistema de Ficheros

La clase java/ioFile representa un path de fichero o directorio en un Sistema de ficheros. Los objetos File soportan la creación, borrado y renombrado de ficheros y directorios y la manipulación de atributos de ficheros tales como solo lectura y tiempo de última vez modificado. Los objetos File que representan directorios pueden usarse para obtener una lista de todos los ficheros y directorios contenidos. La clase java/ioFileDescriptor}} es un descriptor de ficheros que representan una fuente o sumidero (destino) de bytes. Normalmente esto es un fichero, pero puede también ser una consola o un socket de red. Los objetos FileDescriptor se usan para crear streams de File. Se obtienen desde streams File y sockets java.net y sockets de datagrama.

java.nio

En J2SE 1.4, el paquete java.nio (NIO o Nueva I/O) fue añadido para soportar I/O mapeada en memoria, facilitando las operaciones I/O cercanas al hardware subyacente con mejor rendimiento. El paquete java.nio suministra soporte para varios tipos de buffer. El subpaquete java/nio/charset suministra soporte para distintas codificaciones de caracteres para datos de tipo carácter. El subpaquete java/nio/channels suministra soporte para channels, las cuales representan conexiones a entidades que son capaces de realizar operaciones I/O, tales como ficheros y sockets. El paquete java.nio.channels también suministra soporte para bloqueo de grano fino de los ficheros.

java.math

El paquete java.math soporta aritmética multiprecision (incluyendo operaciones aritméticas modulares) y suministra generadores de números primos multiprecision usados para la generación de claves criptográficas. Las clases principales de este paquete son:

BigDecimal – suministra números decimales con signo de precisión arbitraria. BigDecimal da al usuario el control sobre el comportamiento de redondeo a través de RoundingMode.
BigInteger – suministra enteros de precisión arbitraria. Las Operaciones con BigInteger no producen overflow o perdida de precisión. Además de las operaciones aritméticas estándar, suministra aritmética modular, calculo de mínimo común múltiplo, pruebas de números primos, generación de números primos, manipulación de bits, y otras operaciones misceláneas.
MathContext – encapsula las configuraciones de contexto las cuales describen ciertas reglas para operadores numéricos.
RoundingMode – una enumeración que suministra ocho comportamientos de redondeo.

java.net

El paquete java.net suminista rutinas especiales IO para redes, permitiendo las peticiones HTTP, así como también otras transacciones comunes.

java.text

El paquete java.text implementa rutinas de parseo para strings y soporta varios lenguajes legibles por el hombre y parseado específico de la localización.

java.util

Las estructuras de datos que agregan objetos son el foco del paquete java.util. En el paquete está incluida la API Collections, una jerarquía organizada de estructura de datos influenciada fuertemente por considereaciones de patrones de diseño.

Paquetes de propósito especial

java.applet

Creado para soportar la creación de applet Java, el paquete java.applet permite a las aplicaciones ser descargadas sobre una red y ejecutarse dentro de una sandbox. Las restricciones de seguridad son impuestas fácilmente en la sandbox. Un desarrollador, por ejemplo, puede aplicar una firma digital a un applet, en consecuencia etiquetándola como segura. Haciéndolo permite al usuario conceder permiso al applet para realizar operaciones restringidas (tales como acceder al disco duro local), y elimina alguna o todas las restricciones de la sandbox. Los certificados digitales son emitidos por agencias como Thawte o Entrust.

java.beans

Incluidos en el paquete java.beans hay varias clases para desarrollar y manipular beans, componentes reutilizables definidos por la arquitectura JavaBeans. La arquitectura suministra mecanismos para manipular propiedades de componentes y lanzar eventos cuando esas propiedades cambian. La mayoría de las APIs en java.beans están pensadas para su uso po runa herramienta de edición de beans, en la cual los beans puedan combinarse, personalizarse y manipularse. Un tipo de editor bean es el diseñador GUI en un entorno de desarrollo integrado(IDE).

java.awt

La Abstract Window Toolkit contiene rutinas para soportar operaciones básicas GUI y utiliza ventanas básicas desde el sistema nativo subyacente. Muchas implementaciones independientes de la API Java implementan todo excepto AWT, el cual no es usado por la mayoría de las aplicaciones de lado de servidor. Este paquete también contiene la API de gráficos Java 2D.

java.rmi

El paquete java.rmi suministra invocación a métodos remotos Java para soportar llamadas a procedimientos remotos entre dos aplicaciones Java que se ejecutna en diferentes JVM. java.security Soporte para seguridad, incluyendo el algoritmo de resumen de mensaje, está incluido en el paquete java.security.

java.sql

Una implementación de la API JDBC (usada para acceder a bases de datos SQL) se agrupa en el paquete java.sql.

javax.rmi

suministra el soporte para la comunicación remota entre aplicaciones, usando el protocolo RMI sobre IIOP. Este protocolo combina características de RMI y CORBA.

org.omg.CORBA

Suministra el soporte para comunicación remota entre aplicaciones usando general inter ORB protocol y soporta otras características de common object request broker architecture. Igual que RMI y RMI-IIOP, este paquete es para llamar métodos remotos de objetos en otras máquinas virtuales (normalmente por la red). De todas las posibilidades de comunicación CORBA es la más portable entre varios lenguajes. Sin embargo es también un poco difícil de comprender.

javax.swing

Swing es una colección de rutinas que se construyen sobre java.awt para suministrar un toolkit de widgets independiente de plataforma. Swing usa las rutinas de dibujado 2D para renderizar los componentes de interfaz de usuario en lugar de confiar en el soporte GUI nativo subyacente del Sistema operativo.

Swing es un sistema muy rico por sí mismo, soportando pluggable looks and feels (PLAFs) para que los controles(widgets) en la GUI puedan imitar a aquellos del sistema nativo subyacente. Los patrones de diseño impregnan el sistema, especialmente una modificación del patrón modelo-vista-controlador, el cual afloja el acoplamiento entre función y apariencia. Una inconsistencia es que (para J2SE 1.3) las fuentes son dibujadas por el sistema nativo subyacente, limitando la portabilidad de texto. Mejoras, tales como usar fuentes de mapas de bits, existen. En general, las layouts(disposiciones de elementos) se usan y mantienen los elementos dentro de una GUI consistente a través de distintas plataformas.

javax.swing.text.html.parser

Suministra el parser de HTML tolerante a errores que se usa para escribir varios navegadores web y web bots.

Karen Viviana Guevara Oyuela
Código: 221273103
VII semestre Ingeniería de Sistemas

Tomado de Wikipedia, la enciclopedia libre

PAQUETES JAVA

POR: JOHN JAIRO BORDA MENDOZA

__________________________
PAQUETES JAVA
__________________________

Los paquetes informáticos son colecciones de clases, contenidas en una colección que las une. Prácticamente son bibliotecas a las que el usuario puede acceder y que ofrecen varias funciones.
Los usuarios pueden también crear paquetes informáticos, por ejemplo, haciendo que contengan todas las clases que ha definido para poner en marcha algunas funciones que luego usará en varios programas. Sin embargo, esto no nos interesa porque lo que queremos es ver los paquetes informáticos más interesantes en Java.
Esta es la auténtica potencia de Java, el número de clases ya establecidas que realizan las más variadas tareas, y es también la parte que sigue creciendo más y más, y que sigue poniéndose al día con las nuevas versiones de Java (JDK 1.3 bien contiene 18Mb). Veremos de forma detallada algunos, de los que nos sirven para definir interfaces gráficas y apliques. Obviamente todos los paquetes informáticos del lenguaje están descritos en la mastodóntica guía en línea del JDK que se puede bajar junto al paquete del compilador (La JDK Documentation 1.3 beta es de 105 Megabyte, comprimida es de unos treinta Megas).
El núcleo del lenguaje Java contiene sólo las palabras claves para la construcción de las clases, los comentarios, las construcciones normales en if, switch, while, do-while, for, etiquetas, break, continue e return (falta el goto), que veremos en detalle en el próximo capítulo. Todo lo demás está contenido en los paquetes informáticos del lenguaje, incluidas las normales primitivas de Entrada y de Salida. En este párrafo veremos la lista de los paquetes informáticos de Java y veremos uno en particular, el que nos interesa para escribir nuestra primera aplicación Java aún antes de haber visto las construcciones, es decir, en las que podemos encontrar las instrucciones de entrada y salida.La lista completa de los paquetes informáticos de Java 1.2.1 en orden alfabético es el siguiente:

Ø com.sun.image.codec.jpeg
Ø java.applet
Ø java.awt
Ø java.awt.color
Ø java.awt.datatransfer
Ø java.awt.dnd
Ø java.awt.event
Ø java.awt.font
Ø java.awt.geom
Ø java.awt.im
Ø java.awt.image
Ø java.awt.image.renderable
Ø java.awt.print
Ø java.beans
Ø java.beans.beancontext
Ø java.io
Ø java.lang
Ø java.lang.ref
Ø java.lang.reflect
Ø java.math
Ø java.net
Ø java.rmi
Ø java.rmi.activation
Ø java.rmi.dgc
Ø java.rmi.registry
Ø java.rmi.server
Ø java.security
Ø java.security.acl
Ø java.security.cert
Ø java.security.interfaces
Ø java.security.spec
Ø java.sql
Ø java.text
Ø java.util
Ø java.util.jar
Ø java.util.zip
Ø javax.accessibility
Ø javax.swing
Ø javax.swing.border
Ø javax.swing.colorchooser
Ø javax.swing.event
Ø javax.swing.filechooser
Ø javax.swing.plaf
Ø javax.swing.plaf.basic
Ø javax.swing.plaf.metal
Ø javax.swing.plaf.multi
Ø javax.swing.table
Ø javax.swing.text
Ø javax.swing.text.html
Ø javax.swing.text.html.parser
Ø javax.swing.text.rtf
Ø javax.swing.tree
Ø javax.swing.undo
Ø org.omg.CORBA
Ø org.omg.CORBA.DynAnyPackage
Ø org.omg.CORBA.ORBPackage
Ø org.omg.CORBA.portable
Ø org.omg.CORBA.TypeCodePackage
Ø org.omg.CosNaming
Ø sun.tools.ttydebug
Ø unw.io
Ø sunw.util
Ø com.sun.java.swing.plaf.windows,com.sun.java.swing.plaf.motif
Ø org.omg.CosNaming.NamingContextPackage
Realmente parecen pocos, parece que haya dicho una tontería cuando me refería a la potencia de Java, sin embargo si pensáis que sólo el paquete informático Java.io comprende 50 clases y 10 interfaces, comprenderéis que los de antes son una colección de clases consistente.

Llegados a este punto nos gustaría hacer la entrada y la salida de consolle y para hacerlo debemos usar el paquete informático java.lang.
Para usar un paquete informático en una de nuestras clases, antes de definir la clase, tenemos que introducir la instrucción import. Por ejemplo, si queremos usar el paquete informático java.awt tenemos que introducir al comienzo de nuestro archivo:JAVA.AWT.*
El * indica que queremos usar todas las clases, en cambio si queremos usar sólo una clase lo podemos especificar, por ejemplo, import java.awt.Frame; podremos usar la clase Frame del awt. En nuestro caso, en el que queremos hacer una operación de entrada, tendremos que declarar al empezar import java.lang.*;o, sabiendo que la clase del paquete informático java.lang que contiene los métodos para hacerlo es System, podremos escribir.

JAVA.IO
El paquete I/O de Java (java.io) proporciona un juego de canales de entrada y salida utilizados para leer y escribir ficheros de datos y otras fuentes de entrada y salida. Las clases e interfaces definidos en java.io se cubren completamente en Canales de Entrada y Salida.
JAVA.UTIL
Este paquete, java.util, contiene una colección de clases útiles. Entre ellas se encuentan muchas estructuras de datos genéricas (Dictionary, Stack, Vector, Hashtable) un objeto muy útil para dividir cadenas y otro para la manipulación de calendarios. El paquete java.util también contiene el interface Observer y la clase Observable que permiten a los objetos notificarse unos a otros cuando han cambiado. Las clases de java.util no se cubren en este tutorial aunque algunos ejemplos utilizan estas clases.

JAVA.NET
El paquete java.net contiene definiciones de clases e interfaces que implementan varias capacidades de red. Las clases de este paquete incluyen una clase que implementa una conexión URL. Se pueden utilizar estas clases para implementar aplicaciones cliente-servidor y otras aplicaciones de comunicaciones. Conectividad y Seguridad del Cliente tiene varios ejemplos de utilización de estas clases, incluyendo un ejemplo cliente-servidor que utiliza datagramas.

JAVA.APPLET
Este paquete contiene la clase Applet -- la clase que se debe subclasificar si se quiere escribir un applet. En este paquete se incluye el interface AudioClip que proporciona una abstración de alto nivel para audio.Escribir Applets.

JAVA.AWT
El paquete java.awt proporciona elementos GUI utilizados para obtener información y mostrarla en la pantalla como ventanas, botones, barras de desplazamiento, etc.

JAVA.AWT.IMAGE
El paquete java.awt.image contiene clases e interfaces para manejar imágenes de datos, como la selección de un modelo de color, el cortado y pegado, el filtrado de colores, la selección del valor de un pixel y la grabación de partes de la pantalla.

JAVA.AWT.PEER
El paquete java.awt.peer contiene clases e interfaces que conectan los componentes AWT independientes de la plataforma a su implementación dependiente de la plataforma (como son los controles de Microsoft Windows).

JAVA.SQL
Este paquete incluye todos los interfaces que dan acceso a Bases de Datos a través de JDBC, Java DataBase Connectivity, como son: Array, Blob, Connection, Driver, Ref, ResultSet, SQLData, SQLInput, SQLOutput, Statement, Struct; y algunas clases específicas: Date, DriveManager, Time, Types.

java.lang.System
La clase System, a su vez, contendrá en su interior una import java.io (que es el paquete informático para la entrada y la salida) para acceder a las clases de la entrada y de la salida, y las usará para mandar lo que queramos en la pantalla.Vimos un ejemplo de paquete informático que en su interior llama a otro paquete informático para que lleve a cabo unas tareas. En estas bibliotecas Java ocurre eso a menudo y es precisamente este fenómeno que hace de Java un lenguaje incomprensible para la mayoría. Sin embargo, superado este inconveniente que se refiere a este aspecto del lenguaje, la programación se hace fácil e inmediata.He introducido el paquete informático java.lang. Ahora os digo también que este es el más importante de Java, en éste están contenidas las clases fundamentales del lenguaje, hasta el punto de que no hace falta declarara el import, porque Java lo introduce automáticamente.
Si importa en un archivo el paquete informático java.lang, éste importará a su vez el paquete informático java.io, y yo desde mi archivo no podré usar las clases de java.io; para hacerlo tengo que importarlo explícitamente. Esto sucede aunque programe una aplicación en más de un archivo (con más clases), en cada archivo tengo que importar los paquetes informáticos que necesito para la clase que estoy estableciendo, no basta con importarlos en una sola.

Veamos las clases que contiene este paquete informático java.lang tan importante para el lenguaje:
Ø Bolean: Hemos dicho que los tipos de datos se pueden representar también con objetos dichos;
Ø Contenedores: Es una clase que genera los contenedores para los tipos de datos boolean (verdadero, falso).
Ø Byte: Es la clase que genera los contenedores para los tipos de datos enteros cortos (de un byte).
Ø Character: Es una clase que genera los contenedores para los tipos de datos caracteres.
Ø Character.Subset: Es la clase que genera los contenedores para los tipos de datos caracteres con codificación unicode.
Ø Character.UnicodeBlock: Es la clase que genera los contenedores para los tipos de caracteres con codificación unicode 2.0.
Ø Class: Representa las clases y las interfaces a runtime (en ejecución), en Java es posible, en tiempo de ejecución, crear, ejecutar y compilar clases. El compilador y el ejecutor se mezclan de una forma rara, sin embargo a nosostros no nos sirven estas clases "especiales" porque escribiremos unas aplicaciones fáciles.
Ø ClassLoader: Cargador de clases a tiempo de ejecución.
Ø Compiler: Compilador de clases a tiempo de ejecución.
Ø Double: Es la clase que genera los contenedores para los tipos de datos reales en coma móvil de 64 bit.
Ø Exceptions, Errors y Throwable: Cuando ocurre un error en un programa Java, el programa lanza un objeto que indica qué problema era y el estado del interprete cuando ocurrió el error. Sólo los objetos derivados de la clase Throwable pueden ser lanzados. Existen dos subclasses principales de Throwable: Exception y Error. Exception es la forma que deben intentar capturar los programas normales. Error se utiliza para los errores catastróficos--los programas normales no capturan Errores. El paquete java.lang contiene las clases Throwable, Exception y Error, y numerosas subclases de Exception y Error que representan problemas específicos. Manejo de Errores Utilizando Excepciones te muestra cómo utilizar las excepciones para manejar errores en sus programas Java
Ø Flota: Es la clase que genera los contenedores para los tipos de datos reales de 32 bit en coma móvil.
Ø Integer: Es la clase que genera los contenedores para los tipos de datos enteros.
Ø Long: Es la clase que genera los contenedores para los tipos de datos enteros dobles.
Ø Math: Contiene métodos que simulan funciones matemáticas.
Ø Number: Clase de objetos contenedores de números genéricos.
Ø Object: Es la clase de la que derivan todas las clases del lenguaje Java, es decir, cada clase es subclase (no necesariamente directa) de ésta.
Ø Package: Contiene métodos para extrapolar informaciones en los paquetes informáticos de Java.
Ø Process: Java es un lenguaje que permite gestionar Thread, es decir pequeños programas que corren en paralelo. Esta clase se ocupa de ellos, como las demás clases de java.lang: Runtime, RuntimePermission, Thread, ThreadGroup, ThreadLocal, Throwable.
Ø SecurityManager: Para la seguridad
Ø Short: Es la clase que genera los contenedores para los tipos de datos enteros cortos.
Ø String: Es la clase que genera los contenedores para los tipos de datos cadenas de caracteres.
Ø StringBuffer: Es la clase que genera los contenedores para los tipos de datos cadenas de caracteres modificables.
Ø System: Es la clase que interactúa con el sistema y contiene muchos métodos útiles, y unas referencias a otras clases (llamadas class field), es la que usaremos, por ejemplo, para crear una salida sobre la pantalla a caracteres.
Ø Tipos de Datos Encubiertos: Una colección de clases utilizadas para encubrir variables de tipos primitivos: Boolean, Character, Double, Float, Integer y Long. Cada una de estas clases es una subclase de la clase abstracta Number.
Ø Thread: Las clases Thread, ThreadDeath y ThreadGroup implementan las capacidades multitareas tan importantes en el lenguaje Java. El paquete java.lang también define el interface Runnable. Este interface es conveniente para activar la clase Java sin subclasificar la clase Thread. A través de un ejemplo de aproximación Threads de Control te enseñará los Threads Java.
Ø Void: Es la clase que genera los contenedores para los tipos de datos void, es decir, sin tipo. Éste parece un tipo de dato inútil, sin embargo veremos que no lo es en absoluto, además es utilísimo. En realidad, es útil cuando queremos definir un método-procedimiento (un método que no tiene valor de vuelta), en Java existen sólo dos funciones que obligan a devolver un valor del tipo que declaran. Declarando un método como void, se simula el procedimiento, es decir, no se necesita la vuelta.
__________________________

JERARQUÍA DE JAVA
__________________________
Consideremos las figuras planas cerradas como el rectángulo, y el círculo. Tales figuras comparten características comunes como es la posición de la figura, de su centro, y el área de la figura, aunque el procedimiento para calcular dicha área sea completamente distinto. Podemos por tanto, diseñar una jerarquía de clases, tal que la clase base denominada Figura, tenga las características comunes y cada clase derivada las específicas. La relación jerárquica se muestra en la figura.

La clase Figura es la que contiene las características comunes a dichas figuras concretas por tanto, no tiene forma ni tiene área. Esto lo expresamos declarando Figura como una clase abstracta, declarando la función miembro área abstract.
Las clases abstractas solamente se pueden usar como clases base para otras clases. No se pueden crear objetos pertenecientes a una clase abstracta. Sin embargo, se pueden declarar variables de dichas clases.
En el juego del ajedrez podemos definir una clase base denominada Pieza, con las características comunes a todas las piezas, como es su posición en el tablero, y derivar de ella las características específicas de cada pieza particular. Así pues, la clase Pieza será una clase abstracta con una función abstract denominada mover, y cada tipo de pieza definirá dicha función de acuerdo a las reglas de su movimiento sobre el tablero.
La clase Figura
La definición de la clase abstracta Figura, contiene la posición x e y de la figura particular, de su centro, y la función área, que se va a definir en las clases derivadas para calcular el área de cada figura en particular.
public abstract class Figura {
protected int x;
protected int y;
public Figura(int x, int y) {
this.x=x;
this.y=y;
}
public abstract double area();
}
La clase Rectángulo
Las clases derivadas heredan los miembros dato x e y de la clase base, y definen la función area, declarada abstract en la clase base Figura, ya que cada figura particular tiene una fórmula distinta para calcular su área. Por ejemplo, la clase derivada Rectángulo, tiene como datos, aparte de su posición (x, y) en el plano, sus dimensiones, es decir, su anchura ancho y altura alto.
class Rectángulo extends Figura
{
protected double ancho, alto;
public Rectángulo(int x, int y, double ancho, double alto)
{
super(x,y);
this.ancho=ancho;
this.alto=alto;
}
public double area(){
return ancho*alto;
}
}
La primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base, para ello se emplea la palabra reservada super. El constructor de la clase derivada llama al constructor de la clase base y le pasa las coordenadas del punto x e y. Después inicializa sus miembros dato ancho y alto.
En la definición de la función area, se calcula el área del rectángulo como producto de la anchura por la altura, y se devuelve el resultado
La clase Circulo
class Circulo extends Figura
{
protected double radio;
public Circulo(int x, int y, double radio)
{
super(x,y);
this.radio=radio;
}
public double area(){
return Math.PI*radio*radio;
}
}
Como vemos, la primera sentencia en el constructor de la clase derivada es una llamada al constructor de la clase base empleando la palabra reservada súper. Posteriormente, se inicializa el miembro dato radio, de la clase derivada Círculo.
En la definición de la función área, se calcula el área del círculo mediante la conocida fórmula PIr2, o bien PI*r*r. La constante Math.PI es una aproximación decimal del número irracional PI.

Uso de la jerarquía de clases
Creamos un objeto c de la clase Círculo situado en el punto (0, 0) y de 5.5 unidades de radio. Calculamos y mostramos el valor de su área.
Circulo c=new Circulo(0, 0, 5.5);
System.out.println("Area del círculo "+c.area());
Creamos un objeto r de la clase Rectángulo situado en el punto (0, 0) y de dimensiones 5.5 de anchura y 2 unidades de largo. Calculamos y mostramos el valor de su área.
Rectángulo r=new Rectángulo(0, 0, 5.5, 2.0);
System.out.println("Area del rectángulo "+r.area());
Veamos ahora, una forma alternativa, guardamos el valor devuelto por new al crear objetos de las clases derivadas en una variable f del tipo Figura (clase base).
Figura f=new Circulo(0, 0, 5.5);
System.out.println("Area del círculo "+f.area());
f=new Rectangulo(0, 0, 5.5, 2.0);
System.out.println("Area del rectángulo "+f.area());