HTMLpointHTMLpoint HTMLpoint.com


 El paquete java.lang



El Paquete lang

Este paquete lo vimo antes. Ahora, sin embargo, analizaremos algunas funciones que antes no vimos. En primer lugar, hay que decir que éste es uno de los paquetes más importantes de la API Java. Abarca muchísimas clases e interfaces fundamentales para la programación Java, tanto que este paquete se incluye atomáticamente en nuestros programas. Su contenido es::

Intefaces
Cloneable
Comparable
Runnable

Clases
Boolean
Byte
Character
Character.Subset
Character.UnicodeBlock
Class
ClassLoader
Compiler
Double
Float
InheritableThreadLocal
Integer
Long
Math
Number
Object
Package
Process
Runtime
RuntimePermission
SecurityManager
Short
String
StringBuffer
System
Thread
ThreadGroup
ThreadLocal
Throwable
Void

Excepciones
ArithmeticException
ArrayIndexOutOfBoundsException
ArrayStoreException
ClassCastException
ClassNotFoundException
CloneNotSupportedException
Exception
IllegalAccessException
IllegalArgumentException
IllegalMonitorStateException
IllegalStateException
IllegalThreadStateException
IndexOutOfBoundsException
InstantiationException
InterruptedException
NegativeArraySizeException
NoSuchFieldException
NoSuchMethodException
NullPointerException
NumberFormatException
RuntimeException
SecurityException
StringIndexOutOfBoundsException
UnsupportedOperationException

Errores
AbstractMethodError
ClassCircularityError
ClassFormatError
Error
ExceptionInInitializerError
IllegalAccessError
IncompatibleClassChangeError
InstantiationError
InternalError
LinkageError
NoClassDefFoundError
NoSuchFieldError
NoSuchMethodError
OutOfMemoryError
StackOverflowError
ThreadDeath
UnknownError
UnsatisfiedLinkError
UnsupportedClassVersionError
VerifyError
VirtualMachineError

En el primer capítulo vimos las clases que incluyen los tipos primitivos incluidos en este paquete. En este apartado analizaremos unas clases que hacen cosas más complejas.
La primera clase que analizaremos es la clase System, que relacciona nuestro programa Java con el sistema en el que se pone en marcha. En primer lugar, la clase System incluye tres atributos estáticos que son:

static PrintStream err static InputStream in static PrintStream out

Estos programas representan respectivamente el error estándar, el input estándar y el output estándar (que ya utilizamos). Son atributos particulares porque son de tipo clase, por eso se pueden utilizar como referencia para capturar los métodos de las clases, por ejemplo, en la escritura:

System.out.println("Hola");

Se invoca el método println(String) de la classe PrintStream, porque out es de tipo PrintStream. En nuestros ejemplos, utilizamos indiferentemente las expresiones:

System.out.println("Hola");
System.out.println(verdadero);
System.out.println(10);
System.out.println('C');


En general, en Java esto no es posible porque un método se invoca a través de un parámetro formal. Esto no es una excepción. De hecho, invocar el método println con todos estos tipos de datos distintos es posible porque PrintStream incluye todos los métodos println utilizados con el parámetro formal adecuado. Así ésta incluye:

void println()
void println(boolean x)
void println(char x)
void println(char[] x)
void println(double x)
void println(float x)
void println(int x)
void println(long x)
void println(Object x)
void println(String x)

los mismos métodos print, y por supuesto, otros.

Lo mismo vale para err, que es también parecido a un out del tipo PrintStream. Éste se usa para evidenciar los errores de programa. Es bastante fácil encontrar expresiones como las siguientes en los programas:

try {System.out.println(cadena+" vs "+otracadena+" = " +cadena.compareTo(otracadena));}
catch (nullPointerException e)
{System.err.println("ERROR: La segunda cadena es nula");};


En cambio, el atributo in es del tipo InputStream, y representa, como dijimos antes, el estándar input.
Los métodos para actuar sobre él serán, entonces, unos read:

abstract int read()
int read(byte[] b)
int read(byte[] b, int off, int len)


Como es del tipo InputStream, lee unos byte. Si queremos que lea otras cosas tenemos que especializarlo en esta otra cosa. En el siguiente ejemplo, que teclearemos en un archivo que se llama StandardIO.java, le haremos leer enteras líneas.

import java.io.*;
class StandardIO
{
public static void main(String[] temas)
{

System.out.println("Incluye tus input, teclea end [ENVÍO] para salir");

InputStreamReader a=new InputStreamReader(System.in);

BufferedReader IN=new BufferedReader(a);

String s=new String();

while(s.compareTo("end")!=0)
{

try {s=IN.readLine();}
catch (IOException e)
{s="ERROR DE LECTURA";};

System.out.println("Leído: "+s);

}
}
}

Vamos a ver algunos métodos de la clase System:

static long currentTimeMillis(), este método nos devuelve el tiempo en milisegundos
static void exit(int status), este método determina como salir de Java Virtual Machine, con un
código .
static void gc(), Java coloca tantos objetos, y los descoloca, cuando ya no se usan y se necesita nueva
memoria. Para hacerlo, utiliza un Garbage Collector , y este método pone en marcha el garbage collector en cualquier momento para liberar la memoria precedentemente establecida por el programa que todavía no se ha utilizado. Puede resultar muy útil en aplicaciones muy grandes.
static String getenv(String name), nos devuelve una cadena que incluye informacciones con respecto al
sistema con el que se pone en marcha el programa. El método declarado es deprecated en las últimas Documentaciones on line del Java Development Kit porque el método pronto desaparecerá. Es una de las primeras versiones del lenguaje y todavía aparece porque es compatible con el viejo software.
static Properties getProperties() , es el nuevo método para obtener informaciones sobre la propriedad del
sistema.
static String getProperty(String key), como antes, lo único es que recoge informaciones
específicas con respeto a key
static String getProperty(String key, String def)
static void load(String filename) , carga en la memoria el código incluido en filename, que es una
biblioteca dinámica.
static void loadLibrary(String libname), carga la biblioteca de sistema mencionada por libname
static String mapLibraryName(String libname), hace un mapa de una biblioteca en una cadena que la representa.

Hay métodos para volver a asignar los estándars input, output y err, en otros flujos, por ejemplo un archivo.

static void setErr(PrintStream err)
static void setIn(InputStream in)
static void setOut(PrintStream out)


Los siguientes métodos reparan las propiedades del sistema.

static void setProperties(Properties props)
static String setProperty(String key, String value)


Utilizamos unos objetos de tipo Properties y ahora veremos cómo están hechos. Se trata de unas especializaciones de cuadros hash de java y son, en sustancia, unos cuadros que incluyen una serie de parejas Clave - Valor. (En realidad, no son precisamente esto, sino que son unas estructuras muy utilizadas en informática para contener los datos. Pero a nosotros nos interesa verlas así de momento). En particular, las Properties del sistema son:

Clave Descripción del valor asociado
java.version Versión del ambiente de Java Runtime
java.vendor Distribuidor del ambiente de Java Runtime
java.vendor.url URL del destribuidor de Java
java.home Directory donde está instalado Java
java.vm.specification.version Versión de las especificaciones de Java Virtual Machine
java.vm.specification.vendor Distribuidor de las especificaciones de Java Virtual Machine
Nombre de las especificaciones de Java Virtual Machine
java.vm.version Versión de la implementación de Java Virtual Machine
java.vm.vendor Distribuidor de la implementación de Java Virtual Machine
java.vm.name Nombre de la implementación de Java Virtual Machine
java.specification.version Versión del ambiente de Java Runtime
java.specification.vendor Distribuidor del ambiente de Java Runtime Java Runtime
java.specification.name Nombre del ambiente de Java Runtime
java.class.version Versión de las clases de Java
java.class.path Pathname de las clases de Java
os.name Nombre del Sistema Operativo
os.arch Arquitectura del Sistema Operativo
os.version Versión del sistema Operativo
file.separator Separador del Archivo ("/" en UNIX, "\" en Windows)
path.separator Separador de Path (":" en UNIX, ";"en Windows)
line.separator New Line ("\n" en UNIX y Windows)
user.name Account name del usuario
user.home Home directorio del usuario
user.dir Working directorio del usuario


Para eso, podemos escribir un pequeño programa que nos informe sobre el sistema como el siguiente que hay que editar en un archivo que se llama Sistema.java
import java.io.*;

public class Sistema
{

public static void main(String[] arg)
{

// Cambio el estándar output, uso el archivo Sistema.txt

File outFile=new File("Sistema.txt");

FileOutputStream fw;
try {fw=new FileOutputStream(outFile) ;}
catch (IOException e)
{fw=null;};


PrintStream Output=new PrintStream(fw);

System.setOut(Output);


// Escribo en el nuevo estándar output:

// Tiempo:
long tiempo=System.currentTimeMillis();

System.out.println("Tiempo en milisegundos: "+tiempo);

long t1=tiempo/1000;

System.out.println("Tiempo en segundos: "+t1);

long sec=t1%60;

long t3=t1/60;

long min=t3%60;

long t4=t3/60;

System.out.println("Tiempo en horas h"+t4+" m"+min+" s"+sec);

System.out.println("\nEs el tiempo pasado del 1/1/1970 hasta ahora.\n");

// Propiedad del sistema:

System.out.println("\nPropiedad del sistema:\n");
String tmp;

System.out.println("\n\tJAVA\n");

tmp=System.getProperty("java.version ");
System.out.println("Versión del ambiente de Java Runtime: "+tmp);

tmp=System.getProperty("java.vendor");
System.out.println("Distribuidor del ambiente di Java Runtime: "+tmp);

tmp=System.getProperty("java.vendor.url");
System.out.println("URL del distribuidor de Java: "+tmp);

tmp=System.getProperty("java.home");
System.out.println("Directorio donde está instalado Java: "+tmp);

tmp=System.getProperty("java.vm.specification.version");
System.out.println("Versión de las especificaciones de Java Virtual Machine: "+tmp);

tmp=System.getProperty("java.vm.specification.vendor");
System.out.println("Distribuidor de las especificaciones de Java Virtual Machine: "+tmp);

tmp=System.getProperty("java.vm.specification.name");
System.out.println("Nombre de las especificaciones de Java Virtual Machine: "+tmp);

tmp=System.getProperty("java.vm.version");
System.out.println("Versión de la implementación de Java Virtual Machine: "+tmp);

tmp=System.getProperty("java.vm.vendor" );
System.out.println("Distribuidor de la implementación de Java Virtual Machine: "+tmp);

tmp=System.getProperty("java.vm.name");
System.out.println("Nombre de la implementación de Java Virtual Machine: "+tmp);

tmp=System.getProperty("java.specification.version");
System.out.println("Versión del ambiente de Java Runtime: "+tmp);

tmp=System.getProperty("java.specification.vendor");
System.out.println("Distribuidor del ambiente de Java Runtime Java Runtime: "+tmp);

tmp=System.getProperty("java.specification.name" );
System.out.println("Nombre del ambiente de Java Runtime: "+tmp);

System.out.println("\n\tCLASES\n");

tmp=System.getProperty("java.class.version");
System.out.println("Versión de las clases de Java: "+tmp);


tmp=System.getProperty("java.class.path");
System.out.println("Pathname de las clases de Java: "+tmp);

System.out.println("\n\tSISTEMA OPERATIVO\n");


tmp=System.getProperty("os.name");
System.out.println("Nombre del Sistema Operativo: "+tmp);


tmp=System.getProperty("os.arch");
System.out.println("Arquitectura del Sistema Operativo: "+tmp);


tmp=System.getProperty("os.version");
System.out.println("Versión del sistema Operativo: "+tmp);

tmp=System.getProperty("file.separator");
System.out.println("Separador del Archivo: "+tmp);


tmp=System.getProperty("path.separator");
System.out.println("Separador del Pathname: "+tmp);


tmp=System.getProperty("line.separator");
System.out.println("New Line: "+tmp);

System.out.println("\n\tUSUARIO\n");

tmp=System.getProperty("user.name");
System.out.println("Account name del usuario: "+tmp);

tmp=System.getProperty("user.home");
System.out.println("Home directory del usuario: "+tmp);

tmp=System.getProperty("user.dir");
System.out.println("Working directory del usuario: "+tmp);


}

}

Puesto en marcha en mi sistema, el output fue (Sistema.txt):

Tiempo en milisegundos: 956241233430
Tiempo en segundos: 956241233
Tiempo en horas h265622 m33 s53

Es el tiempo transcurrido del 1/1/1970 hasta ahora.

Propiedad del sistema:

JAVA

  1. Versión del ambiente de Java Runtime: null
  2. Distribuidor del ambiente de Java Runtime: Sun Microsystems Inc.
  3. URL del distribuidor de Java: http://java.sun.com/
  4. Directorio donde está instalado Java: C:\PROGRAMAS\JAVASOFT\JRE\1.3
  5. Versión de las especificaciones de Java Virtual Machine: 1.0
  6. Distribuidor de las especificaciones de Java Virtual Machine: Sun Microsystems Inc.
  7. Nombre de las especificaciones de Java Virtual Machine: Java Virtual Machine Specification
  8. Versión de la implementación de Java Virtual Machine: 1.3.0rc1-S
  9. Distribuidor de la implementación de Java Virtual Machine: Sun Microsystems Inc.
  10. Nombre de la implementación de Java Virtual Machine: Java HotSpot(TM) Client VM
  11. Versión del ambiente de Java Runtime: 1.3
  12. Distribuidor del ambiente de Java Runtime Java Runtime: Sun Microsystems Inc.
  13. Nombre del ambiente de Java Runtime: Java Platform API Specification
CLASSI
  1. Versión de las clases de Java: 47.0
  2. Pathname de las clases de Java: .
SISTEMA OPERATIVO

  1. Nombre del Sistema Operativo: Windows 95
  2. Arquitectura del Sistema Operativo: x86
  3. Versión del sistema Operativo: 4.0
  4. Separador del Archivo: \
  5. Separador del Pathname: ;
  6. New Line:
USUARIO

  1. Account name del usuario: pietro
  2. Home directory del usuario: C:\WINDOWS\Profiles\Pietr000
  3. Working directory del usuario: D:\Lavoro\HTMLpoint\corso\esempi\cap3\lez6
Otra clase muy importante del paquete java.lang di Java es la clase Object. Ésta es la clase desde la que se crean todas las demás clases de Java, es decir, cualquier otra clase de Java es una extensión de la clase java.lang.Object. La class Object no incluye ninguna variable, sino que incluye 11 métodos que se heredan de todas las demás clases de java y pueden ser utilizadas en cualquier objeto fijado en Java, entre las que:
clone(), que crea una copia del objeto idéntica a la de la que invoca el método. En este caso hay que fijarse en que el mismo programa Java es un Objeto, por eso, se pueden crear un número arbitrario de programas todos idénticos. Para que se pueda invocar el método clone() de un objeto, este tiene que implementar la interfaz Cloneable .
getClass(), devuelve un Objeto de tipo Class que representa la clase a la que pertenece el objeto cuyo método fue solicitado.
toString(), transforma el objeto en una cadena. Este método tiene que ser escrito otra vez en los objetos creados por el usuario, pero es muy útil.

Pensemos en la escritura Cadena suma="Sumando"+10+" y "+11+" tengo "+(10+11);
Creamos una cadena usando unas cadenas y unos int. De forma automática, en este caso Java invoca el método toString() de la clase correspondiente que lo contiene. Esto ocurre en cada expresión que abarca cadenas y objetos como "Cadena"+Objeto.

La otra clase del paquete a la que nos referimos antes es Class y representa las clases del lenguaje. Es muy importante porque tiene más de treinta métodos que sirven para gestionar las clases a runtime, lo que es imprenscindible en los demás lenguajes de programación. Objetos de este tipo, llamados descriptores de clase, aunque sean ellos mismos descriptores de interfaces, se crean y se asocian automáticamente a los objetos a los que se refieren.
Objetos de tipo Class, Object y otros tipos, son muy importantes si son a runtime porque permiten gestionar el programa que se está poniendo en marcha como si fuera una colección de datos sobre los que es posible trabajar.
Java es un lenguaje de potencialidad impresionante. Si pensamos en java.lang, hay una clase que se llama Compiler que incluye métodos para redactar fuentes Java. Hay otras clases como ClassLoader, Runtime... que permiten cargar nuevas clases a runtime, ponerlas en marcha, y modificar el programa mismo mientras está trabajando. Potencialmente, es posible escribir en Java partiendo del código que se automodifica (que evoluciona).
Llegados a este punto para terminar la explicación de java.lang, entre otras cosas porque verlo de forma detallada es demasiado complicado y sin duda está fuera de los fines de nuestro curso, nos basta con saber que existe y que hace cosas que para los otros lenguajes de programación es pura fantasía o, como mínimo, es imposible o dificilísimo trabajar a niveles altos.
Antes de acabar descrivo brevemente la clase java.lang.Match (diferente de la clase java.math).
Esta clase sirve para hacer cálculos matemáticos y tiene dos atributos:

static double E , es la e de Eulero
static double PI, es la PI griega


Los métodos son obviamente todas las funciones matemáticas calculables, entre las que:

  1. Los valores absolutos de valores double, float, int e long:
  2. static double abs(double a)
  3. static float abs(float a)
  4. static int abs(int a)
  5. static long abs(long a)
Las funciones trigonométricas

  1. static double acos(double a) - arcocoseno
  2. static double asin(double a) - arcoseno
  3. static double atan(double a) - arcotangente
  4. static double cos(double a) - coseno
  5. static double sin(double a) - seno
  6. static double tan(double a) - tangente
Transformaciones de ángulos

  1. static double toDegrees(double angrad) - convierte radiantes en grados
  2. static double toRadians(double angdeg) - convierte grados en radiantes
  3. static double atan2(double a, double b) - convierte coordinadas cartesianas (b,a) en coordinadas polares (r,theta)
Funciones exponenciales y logarítmicas

  1. static double exp(double a) - y elevado a la a.
  2. static double log(double a) - logaritmo en base y de a
Máximos y mínimos entre valores double, float, int e long

  1. static double max(double a, double b)
  2. static float max(float a, float b)
  3. static int max(int a, int b)
  4. static long max(long a, long b)
  5. static double min(double a, double b)
  6. static float min(float a, float b)
  7. static int min(int a, int b)
  8. static long min(long a, long b)
Potencias y raíces

  1. static double pow(double a, double b) - calcula a elevado a la b, notar que si b es <1, esta es
  2. una raíz(1/b)-esima de a
  3. static double sqrt(double a) - calcula la raíz cuadrada de a.
Números pseudocasuales

  1. static double random() - da un numero casual entre 0 y 1
Redondeos

  1. static double rint(double a) - parte entera baja de a, es un entero
  2. static long round(double a) - a redondeado, es un long
  3. static int round(float a) - a redondeado, es un entero
Visto que hemos nombrado el paquete java.math, digamos que éste contiene dos clases, BigInteger e BigDecimal. La primera clase sirve para tratar números enteros de tamaño arbitrario, pongamos por ejemplo el cálculo factorial de un número muy grande, este será un número exageradamente grande. BigDecimal hace lo mismo con los números particulares.


  Vuelva al inicio de la página