John Jairo Borda Mendoza Codigo. 221103104

__________________________

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 de los paquetes informáticos de Java 1.2.1 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

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());