Clases Java

La clase Date se utiliza para representar una fecha y una hora. Se pueden manipular el día, mes, año, día de la semana, horas minutos y segundos.

La clase Date maneja fechas y horas UTC (Universal Time Coordinated), aunque su precisión depende del host en que se esté ejecutando la Máquina Virtual Java. Hay veces en que se indica el tiempo en términos GMT (Greenwich Mean Time), que es equivalente al Tiempo Universal, UT (Universal Time). GMT es el nombre civil para el estándar y UT es el nombre científico para ese mismo estándar. Y, la distinción entre UTC y UT es que UTC se basa en un reloj atómico y UT está basado en observaciones astronómicas, pero la diferencia existente entre los dos es bien poca.

Constructores

Hay varios constructores para objetos Date, que ofrecen más o menos nivel de especificidad para la precisión que se desea para la hora.

Métodos de Date

Antes del JDK 1.1, esta clase tenía métodos para acceder a todos los elementos de la fecha, pero adolecía del tremendo defecto de que se basaba en el formato de fecha americano, con lo cual no se permitía el uso de fechas de otros países. Para proporcionar esta internacionalización, se incluye la clase Calendar, que es una clase base abstracta para realizar las conversiones entre un objeto Date y todos sus campos como YEAR, MONTH, DAY, HOUR y demás; basándose en el objeto Date que tiene precisión de milisegundos.

La Clase Properties

Hay ocasiones en que es necesario que el sistema sea capaz de leer atributos determinados de ese sistema, y ser capaz de leer y/o modificar atributos específicos de la aplicación. Los mecanismos que Java proporciona para resolver estas tareas son tres: argumentos en la línea de comandos y parámetros en la llamada a applets y las propiedades.

El tópico de Propiedades, Properties, es uno de los que nunca cambian técnicamente y que son terriblemente insufribles hasta que se necesitan. Y, cuando son necesarios, lo son de verdad.

Las Propiedades definen un entorno persistente, es decir, se pueden fijar atributos a través de las Propiedades que sean necesarios en la invocación de programas. En otras palabras, si hay alguna información que deba proporcionarse a un programa cada vez que se ejecute, entonces las Propiedades pueden ser la solución. Por supuesto, esto implica que haya acceso disponible a sistemas de almacenamiento fijo. Por ahora, en el momento en que se está escribiendo esto, invierno del 97, las aplicaciones Java tienen acceso a los ficheros de disco en la máquina en que se están ejecutando, mientras que los applets tienen este acceso denegado.

Para que un applet pueda hacer uso de las Propiedades, sería necesario que el applet tuviese acceso a un dispositivo de almacenamiento fijo en el servidor desde el que ha sido descargado; porque, por ahora, el acceso a servidores de red de un applet está limitado al servidor desde el que ha sido descargado.

Las Propiedades vienen representadas por objetos de la clase Properties. Estos objetos se pueden almacenar en disco y recuperarse cuando se necesiten, si se dispone del adecuado acceso a disco.

Las Propiedades se almacenan en variables de instancia del objeto en forma de pares clave/valor. Cada propiedad individual se identifica a través de una clave y el valor que se asigna a una clave viene determinado por el miembro valor del par. Tanto la clave como el valor son cadenas.

El programa java813.java instancia un objeto Properties para presentar en pantalla las Propiedades por defecto del sistema en la estación de trabajo que utilizo en la empresa. La salida es la siguiente:

C:\>java java813
-- listing properties --
user.language=en
java.home=/usr/local/java
java.vendor.url.bug=http://java.sun.com/cgi-bin/bugreport...
file.encoding.pkg=sun.io
java.version=1.1.4
file.separator=/
line.separator=

file.encoding=8859_1
java.vendor=Sun Microsystems Inc.
user.timezone=MET
user.name=froufe
os.arch=sparc
os.name=Solaris
java.vendor.url=http://www.sun.com/
user.dir=/home/usuarios/froufe/java/tutorial/fue...
java.class.path=.:/usr/local/lib/classes.zip;/us...
java.class.version=45.3
os.version=2.x
path.separator=:
user.home=/home/usuarios/froufe

Y el código del programa es el que se muestra:

import java.util.*;
import java.lang.*;

class java813 {
    public static void main( String args[] ) {
        // Instancia y presenta un objeto Properties para presentar 
        // las caracteristicas del sistema
        Properties obj = new Properties( System.getProperties() );

        obj.list( System.out );
        }
    }

Como se puede observar, lo fundamental en este programa son las dos líneas del cuerpo del método en donde se instancia un objeto Properties y se listan las Propiedades por defecto del sistema que contiene ese objeto.

Las Propiedades del sistema en un momento dado se pueden obtener llamando al método getProperties() de la clase System. El método list() de la clase Properties sería luego el utilizado para visualizar el contenido del objeto.

Una vez que se ha creado un objeto Properties para el programa, se pueden guardar en un dispositivo de almacenamiento fijo utilizando el método save() y posteriormente recuperarlos a través del método load(). Las Propiedades del sistema son mantenidas a través de la clase java.lang.System.

La Clase Runtime

Esta clase encapsula el proceso del intérprete Java que se ejecute. No se puede crear una instancia de Runtime; sin embargo, se puede obtener una referencia al objeto Runtime que se está ejecutando actualmente llamando al método estático Runtime.getRuntime(). Los applets y otros fragmentos de código de los que se desconfíe habitualmente no pueden llamar a ninguno de los métodos de la clase Runtime sin activar una SecurityException, excepción de seguridad. Algo sencillo que se puede realizar sobre el proceso en ejecución es provocar que se detenga con un código de salida, utilizando el método exit( int ) de la clase System, donde int es el código que devolverá el programa.

Aunque Java es un sistema de recogida de basura automática, o liberación de memoria automática, se podría desear el conocer la cantidad de objetos y el espacio libre que hay, para comprobar la eficiencia del código escrito. Para proporcionar esta información, la clase Runtime dispone de los métodos totalMemory(), que devuelve la memoria total en la Máquina Virtual Java, y freeMemory(), que devuelve la cantidad de memoria libre disponible.

También se puede ejecutar el recolector de basura bajo demanda, llamando al método gc() de la clase System. Algo bueno que se puede intentar es llamar a gc(), y después llamar a freeMemory() para obtener la utilización de memoria base. A continuación, se ejecuta el código desarrollado y se llama a freeMemory() de nuevo para ver cuánta memoria está asignando.

En entornos seguros se puede hacer que Java ejecute otros procesos intensivos en un sistema operativo multitarea. Hay varios constructores del método exec() que permiten que se indique el nombre del programa que se va a ejecutar, junto con los parámetros de entrada. El método exec() devuelve un objeto Process, que se puede utilizar para controlar la interacción del programa Java con el nuevo proceso en ejecución. El problema a la hora de documentar exec() es que los programas que se ejecutan son muy dependientes del sistema. Se podría hacer exec( "/usr/bin/ls" ) en Solaris/Linux y exec( "notepad" ) en Windows 95/NT.

En el ejemplo java814.java, una aplicación específica de Windows de exec() lanza el Bloc de Notas, el editor de textos simple, en uno de los archivos fuente de Java. Tómese nota que exec() convierte automáticamente el carácter "/ " en el separador de camino de Windows "\".

class java814 {
    public static void main( String args[] ) {
        Runtime r = Runtime.getRuntime();
        Process p = null;
        String comando[] = { "notepad","java814.java" };

        // Datos de la memoria del Sistema
        System.out.println( "Memoria Total = "+ r.totalMemory() +
            " Memoria Libre = "+ r.freeMemory() );

        // Intenta ejecutar el comando que se le indica, en
        // este caso lanzar el bloc de notas
        try {
            p = r.exec( comando );
        } catch( Exception e ) {
            System.out.println( "Error ejecutando "+comando[0] );
            }
    }

Hay varias formas alternativas de exec(), pero esta es la más habitual. El proceso que devuelve exec() se puede manipular después de que el nuevo programa haya comenzado a ejecutarse. Se puede eliminar el subproceso con el método destroy(). El método waitFor(), esperar a, provoca que el programa espere hasta que el subproceso termine, y el método exitValue(), valor de salida, devuelve el valor que ha devuelto el subproceso cuando terminó. En el ejemplo java815.java, se presenta el mismo código del ejemplo anterior, modificado para que espere a que termine el proceso en ejecución.

class java815 {
    public static void main( String args[] ) {
        Runtime r = Runtime.getRuntime();
        Process p = null;
        String comando[] = { "notepad","java814.java" };

        try {
            p = r.exec( comando );
            p.waitFor();
        } catch( Exception e ) {
            System.out.println( "Error ejecutando "+comando[0] );
            }
        System.out.println( 
            comando[0]+" ha devuelto "+p.exitValue() );
        }
    }

Este ejemplo espera hasta que se abandone el Bloc de Notas, después imprime el código devuelto, que es 0.

Home | Anterior | Siguiente | Indice | Correo