New 2 Java: Construir una Aplicación: 1.- Objetos de una Aplicación

• Paquetes
• Paquetes
• Prepararnos para el Interface Gráfico de Usuario (GUI)
• Definición de Clases

Paquetes

¿Cuál es el propósito de la palabra clave package?

El propósito de usar la palabra clave package es agrupar y almacenar las clases relacionadas en un contenedor, y hacer que las clases del paquete estén disponibles para el compilador.

 Paquetes

El lenguaje Java tiene muchas clases predefinidas que pueden ser usadas en las aplicaciones. Hay tantas que las clases han tenido que ser organizadas en grupos llamados paquetes.

Por ejemplo, las clases que soportan I/O (input y output) están contenidas en el paquete java.io, y las clases para crear applets están en el paquete java.applet. Poner las clases en paquetes las organiza convenientemente para el compilador y para tí.

Cuando creamos aplicaciones, ponemos nuestras clases en nuestro paquete de aplicación particular. La aplicación Dive Log almacena sus ficheros en un paquete llamado divelog. Esto le dice a cualquiera que mire el código que las clases de la aplicación Dive Log están en un directorio llamado divelog, igual que las clases java.applet están en un directorio llamando applet, que es un directorio bajo java. En otras palabras, los nombres de paquetes corresponden con los nombres de directorios.

El paquete java.applet teine la estructura de directorio:

/java/
   |
    /applet

Nuestro paquete divelog tiene la estructura de directorios:

C:\divelog

o

%/usr/home/divelog

Cuando usemos las clases predefinidas de los APIs de Java, el compilador necesita localizar dichas clases. Le palabra clave package es sólo para mapear las clases de nuestra aplicación particular, no las clases del API Java que podríamos usar. Al compilador se le puede decir de dos formas qué clases necesita y donde están:

• Escribiendo el nombre completo del paquete y de la clase (nombre totalmente cualificado):
  java.applet.Applet
• Usando una sentencia import al principio de nuestra clase:
  import java.applet.*;

La segunda forma, usar las sentencias import, le dice al compilador que nuestra clase incluye clases del paquete java.applet. De esta forma, después de la sentencia import, sólo tenemos que nombrar la clase en vez de tener que escribir el nombre totalmene cualificado como en el primer ejemplo.

 Prepararnos para el Interface Gráfico de Usuario (GUI)

Dive Log es una aplicación con un Interface Gráfico de Usuario (GUI). De hecho, la mayoría de la aplicación es el propio interface. Con la creación de las características gráficas como los menús, las pestañas, las imágenes, etc., nos familiarizaremos con el Proyecto Swing, los APIs Java que proporcionan muchas clases predefinidas para aplicaciones GUI. Además, aprenderemos sobre el AWT, otro gran conjunto de APIs Java que proporciona clases para diseñar la distribución de objetos gráficos, y la funcionalidad llamada manejo de eventos.

Importar Paquetes

Para hacer sencillo el uso de las clases Swing y AWT, incluimos las sentencias import en nuestra clase:

Estas sentencias import nos permiten fácilmente acceder a las clases predefinidas en estos paquetes. En este caso, se han importado los paquetes con clases para componentes gráficos, por eso ahora no necesitamos teclear sus nombres totalmente cualificados, en su lugar podemos teclear directamente el nombre de la clase que necesitamos usar. En otras palabras, las sentencias import nos ofrecen un atajo a los nombres de las clases de otros paquetes. Veremos más ejemplos a lo largo de este tutorial.

 Definición de Clases

Después de los nombres de paquetes y las sentencias import, estámos listos para definir la clase. La primera clase a definir es el marco de trabajo para la propia aplicación, la clase DiveLog:

public class DiveLog
{

Esta línea le dice al compilador:

• La clase es public, lo que significa que es accesible desde cualquier otra clase en cualquier otro paquete.
• Que esto es una clase, de ahí la palabra clave class.
• Que el nombre de la clase es DiveLog.

// This is a single line comment.
/* This format is often used for 
multiline comments. */

Observa que el nombre de la clase empieza con una letra mayúscula. Las convenciones de nombrado dicen que la primera letra del nombre de una clase sea en mayúsculas y la primera letra de los nombres de métodos en minúscula. Usando este esquema de nombrado es fácil leer el código porque los nombres de las clases son diferentes de los nombres de métodos y de variables.

El corchete { empieza la definición de la clase. Al final de la clase debe hacer un corchete de cierre }. Los corchetes significan el inicio y el final de la clases, los cuerpos de los métodos y las sentencias.

Perder o añadir corchetes de más es una de las causas más comunes de errores de compilación. Es una buena idea crear los corchetes en parejas, y luego insertar el código que va entre ellos, así, en este método:

Primero:

public void actionPerformed(ActionEvent e)
 {

 }

Segundo:

public void actionPerformed(ActionEvent e)
 {
     System.exit(0);
 }

Declarar Variables

Los objetos contienen datos, y las variables son contenedores de datos, o mejor, referencias de datos. La idea que hay detrás del uso de una variable, una referencia al dato, en vez del propio dato es que así podemos manipular el dato.

Por ejemplo, en el ejemplo de abajo birthYear y currentYear son dos valores datos, mientras que age representa birthYear restado de currentYear:

birthYear = 1981;
currentYear = 2001;
age = currentYear - birthYear;

En este ejemplo, la variable age teine un valor de 20. Si cambiamos el valor de birthYear o de currentYear el valor de age también cambiará de forma conveniente.

Las variables no tienen que ser codificadas a lo bruto. La variable birthYear puede estar asignada a un campo de texto para que el usuario introduzca un número. Luego la variable currentYear podría está codificada directamente, declarando el año actual, como 2001. Este tipo de variables hacen las aplicaciones dinámicas. Mientras que un usuario teclea 1962 como valor de birthYear, otro usuario puede teclear 1982 como valor de birthYear, y se calculará un valor diferente para age con cada entrada de usuario.

Usando las variables de esta forma para representar datos, un programador no tiene porque conocer los valores por adelantado. Las aplicaciones bancarias tiene variables que representan nombres de clientes, direcciones, números de cuentas, saldos de las cuentas, etc., junto con variables codificadas directamente como los tipos de interés y las tasas bancarias.

En el lenguaje de programación Java, los tipos de variables deben declararse con su nombre. En otras palabras, el compilador tiene que conocer si la variable va a representar un String, un int, o algún otro tipo de dato. Por ejemplo para compilar el código de arriba deberíamos reescribirlo como:

int birthYear = 1981;
int currentYear = 2001;
int age = currentYear - birthYear;

Mira atentamente el código de arriba, luego, si puedes, responde a la pregunta de abajo: