Java un Lenguaje Potente

Actualización de Información

2009-11-20T20:20:00.000-08:00

Actualización de Información

Se pueden utilizar ficheros de acceso aleatorio para añadir información a ficheros existentes:

    miRAFile = new RandomAccessFile( "/tmp/kk.log","rw" );
   miRAFile.seek( miRAFile.length() );
   // Cualquier write() que hagamos a partir de este punto del código
   // añadirá información al fichero

Vamos a ver un pequeño ejemplo, Log.java , que añade una cadena a un fichero existente:

import java.io.*;

// Cada vez que ejecutemos este programita, se incorporara una nueva
// linea al fichero de log que se crea la primera vez que se ejecuta
//
class Log {
   public static void main( String args[] ) throws IOException {
       RandomAccessFile miRAFile;
       String s = "Informacion a incorporarnTutorial de Javan";

       // Abrimos el fichero de acceso aleatorio
       miRAFile = new RandomAccessFile( "/tmp/java.log","rw" );
       // Nos vamos al final del fichero
       miRAFile.seek( miRAFile.length() );
       // Incorporamos la cadena al fichero    
       miRAFile.writeBytes( s );
       // Cerramos el fichero
       miRAFile.close();
       }
   }

Acceso a la Información

2009-11-15T20:19:00.000-08:00

Acceso a la Información

Los objetos RandomAccessFile esperan información de lectura/escritura de la misma manera que los objetos DataInput/DataOutput. Se tiene acceso a todas las operaciones read() y write() de las clases DataInputStream y DataOutputStream .

También se tienen muchos métodos para moverse dentro de un fichero:

long getFilePointer();

Devuelve la posición actual del puntero del fichero

void seek( long pos );

Coloca el puntero del fichero en una posición determinada. La posición se da como un desplazamiento en bytes desde el comienzo del fichero. La posición 0 marca el comienzo de ese fichero.

long length();

Devuelve la longitud del fichero. La posición length() marca el final de ese fichero.

FICHEROS DE ACCESO ALEATORIO

2009-11-10T20:19:00.000-08:00

FICHEROS DE ACCESO ALEATORIO

A menudo, no se desea leer un fichero de principio a fin; sino acceder al fichero como una base de datos, donde se salta de un registro a otro; cada uno en diferentes partes del fichero. Java proporciona una clase RandomAccessFile para este tipo de entrada/salida.

Creación de un Fichero de Acceso Aleatorio

Hay dos posibilidades para abrir un fichero de acceso aleatorio:

Con el nombre del fichero:

    miRAFile = new RandomAccessFile( String nombre,String modo );

Con un objeto File:

    miRAFile = new RandomAccessFile( File fichero,String modo );

El argumento modo determina si se tiene acceso de sólo lectura ( r ) o de lectura/escritura ( r/w ). Por ejemplo, se puede abrir un fichero de una base de datos para actualización:

    RandomAccessFile miRAFile;
   miRAFile = new RandomAccessFile( "/tmp/kk.dbf","rw" );

Escritura en un objeto DataOutputStream

2009-11-05T20:18:00.000-08:00

Escritura en un objeto DataOutputStream
Cada uno de los métodos write() accesibles por los FileOutputStream también lo son a través de los DataOutputStream. También encontrará métodos complementarios a los de DataInputStream:

    void writeBoolean( boolean b );
   void writeByte( int i );
   void writeShort( int i );
   void writeChar( int i );
   void writeInt( int i );
   void writeFloat( float f );
   void writeDouble( double d );
   void writeBytes( String s );
   void writeChars( string s );

Para las cadenas, se tienen dos posibilidades: bytes y caracteres. Hay que recordar que los bytes son objetos de 8 bits y los caracteres lo son de 16 bits. Si nuestras cadenas utilizan caracteres Unicode, debemos escribirlas con writeChars().

Contabilidad de la salida
Otra función necesaria durante la salida es el método size(). Este método simplemente devuelve el número total de bytes escritos en el fichero. Se puede utilizar size() para ajustar el tamaño de un fichero a múltiplo de cuatro. Por ejemplo, de la forma siguiente:

    . . .
   int numBytes = miDataStream.size() % 4;
   for( int i=0; i < numBytes; i++ )
       miDataStream.write( 0 );
   . . .

Streams DataOutput

2009-10-25T20:17:00.000-07:00

Streams DataOutput
Java también implementa una clase de salida complementaria a la clase DataInputStream. Con la clase DataOutputStream, se pueden escribir datos binarios en un fichero.

Apertura y cierre de objetos DataOutputStream
Para abrir y cerrar objetos DataOutputStream, se utilizan los mismos métodos que para los objetos FileOutputStream:

DataOutputStream miDataStream;
FileOutputStream miFileStream;
BufferedOutputStream miBufferStream;

// Obtiene un controlador de fichero
miFileStream = new FileOutputStream( "/tmp/kk" );
// Encadena un stream de salida con buffer (por eficiencia)
miBufferStream = new BufferedOutputStream( miFileStream );
// Encadena un fichero de salida de datos
miDataStream = new DataOutputStream( miBufferStream );

// Ahora se pueden utilizar los dos streams de entrada para
// acceder al fichero (si se quiere)
miBufferStream.write( b );
miDataStream.writeInt( i );

// Cierra el fichero de datos explícitamente. Siempre se cierra
// primero el fichero stream de mayor nivel
miDataStream.close();
miBufferStream.close();
miFileStream.close();

Volcado y Cierre de Streams de salida con buffer

2009-10-20T20:17:00.000-07:00

Volcado y Cierre de Streams de salida con buffer
Al contrario que los streams FileOutput, cada escritura al buffer no se corresponde con una escritura en disco. A menos que se llene el buffer antes de que termine el programa, cuando se quiera volcar el buffer explícitamente se debe hacer mediante una llamada a flush():

    // Se fuerza el volcado del buffer a disco
   miBufferStream.flush();
   // Cerramos el fichero de datos. Siempre se ha de cerrar primero el
   // fichero stream de mayor nivel
   miBufferStream.close();
   miFileStream.close();

Escritura en un FileOutputStream

2009-10-15T20:16:00.000-07:00

Escritura en un FileOutputStream
Una vez abierto el fichero, se pueden escribir bytes de datos utilizando el método write(). Como con el método read() de los streams de entrada, tenemos tres posibilidades:

void write( int b );

Escribe un byte.

void write( byte b[] );

Escribe todo el array, si es posible.

void write( byte b[],int offset,int longitud );

Escribe longitud bytes en b comenzando por b[offset].

Cierre de FileOutputStream
Cerrar un stream de salida es similar a cerrar streams de entrada. Se puede utilizar el método explícito:

    miFicheroSt.close();

O, se puede dejar que el sistema cierre el fichero cuando se recicle miFicheroSt.

Ejemplo: Almacenamiento de Información
Este programa, Telefonos.java, pregunta al usuario una lista de nombres y números de teléfono. Cada nombre y número se añade a un fichero situado en una localización fija. Para indicar que se ha introducido toda la lista, el usuario especifica "Fin" ante la solicitud de entrada del nombre.

Una vez que el usuario ha terminado de teclear la lista, el programa creará un fichero de salida que se mostrará en pantalla o se imprimirá. Por ejemplo:

    95-4751232,Juanito
   564878,Luisa
   123456,Pepe
   347698,Antonio
   91-3547621,Maria

El código fuente del programa es el siguiente:

import java.io.*;

class Telefonos {
   static FileOutputStream fos;
   public static final int longLinea = 81;

   public static void main( String args[] ) throws IOException {
       byte tfno[] = new byte[longLinea];
       byte nombre[] = new byte[longLinea];

       fos = new FileOutputStream( "telefono.dat" );
       while( true )
           {
           System.err.println( "Teclee un nombre ('Fin' termina)" );
           leeLinea( nombre );
           if( "fin".equalsIgnoreCase( new String( nombre,0,0,3 ) ) )
               break;

           System.err.println( "Teclee el numero de telefono" );
           leeLinea( tfno );
           for( int i=0; tfno[i] != 0; i++ )
               fos.write( tfno[i] );
           fos.write( ',' );
           for( int i=0; nombre[i] != 0; i++ )
               fos.write( nombre[i] );
           fos.write( 'n' );
           }
       fos.close();
       }

   private static void leeLinea( byte linea[] ) throws IOException {
       int b = 0;
       int i = 0;

       while( (i < ( longLinea-1) ) &&
           ( ( b = System.in.read() ) != 'n' ) )
           linea[i++] = (byte)b;
       linea[i] = (byte)0;
       }
   }

Objetos FileOutputStream

2009-10-10T20:15:00.000-07:00

Objetos FileOutputStream
Los objetos FileOutputStream son útiles para la escritura de ficheros de texto. Como con los ficheros de entrada, primero se necesita abrir el fichero para luego escribir en él.

Apertura de un FileOutputStream
Para abrir un objeto FileOutputStream, se tienen las mismas posibilidades que para abrir un fichero stream de entrada. Se le da al constructor un String o un objeto File.

    FileOutputStream miFicheroSt;
   miFicheroSt = new FileOutputStream( "/etc/kk" );

Como con los streams de entrada, también se puede utilizar:

File miFichero FileOutputStream miFicheroSt;

File miFichero FileOutputStream miFicheroSt;

   miFichero = new File( "/etc/kk" );
   miFicheroSt = new FileOutputStream( miFichero );

STREAMS DE SALIDA

2009-10-05T20:15:00.000-07:00

STREAMS DE SALIDA

La contrapartida necesaria de la lectura de datos es la escritura de datos. Como con los Streams de entrada, las clases de salida están ordenadas jerárquicamente:

Examinaremos las clases FileOutputStream y DataOutputStream para complementar los streams de entrada que se han visto. En los ficheros fuente del directorio $JAVA_HOME/src/java/io se puede ver el uso y métodos de estas clases, así como de los streams de entrada ($JAVA_HOME es el directorio donde se haya instalado el Java Development Kit, en sistemas UNIX).

Apertura de un Stream de entrada de URL

2009-09-28T20:14:00.000-07:00

Apertura de un Stream de entrada de URL
También se puede abrir un stream de entrada a partir de un URL. Por ejemplo, se puede utilizar un fichero de datos para un applet:

ImputStream is;
byte buffer[] = new byte[24];
is = new URL( getDocumentBase(),datos).openStream();

Ahora se puede utilizar is para leer información de la misma forma que se hace con un objeto FileInputStream:

is.read( buffer,0,buffer.length );

NOTA: Debe tenerse muy en cuenta que algunos usuarios pueden haber configurado la seguridad de sus navegadores para que los applets no accedan a ficheros.

Streams de entrada de URLs

2009-09-25T20:13:00.000-07:00

Streams de entrada de URLs
Además del acceso a ficheros, Java proporciona la posibilidad de acceder a URLs como una forma de acceder a objetos a través de la red. Se utiliza implícitamente un objeto URL al acceder a sonidos e imágenes, con el método getDocumentBase() en los applets:

    String imagenFich = new String( "imagenes/pepe.gif" );
   imagenes[0] = getImage( getDocumentBase(),imagenFich );

No obstante, se puede proporcionar directamente un URL, si se quiere:

    URL imagenSrc;
   imagenSrc = new URL( "http://enterprise.com/~info" );
   imagenes[0] = getImage( imagenSrc,"imagenes/pepe.gif" );

Streams de salida con buffer

2009-09-20T20:16:00.000-07:00

Streams de salida con buffer
Si se trabaja con gran cantidad de datos, o se escriben muchos elementos pequeños, será una buena idea utilizar un stream de salida con buffer. Los streams con buffer ofrecen los mismos métodos de la clase FileOutputStream, pero toda salida se almacena en un buffer. Cuando se llena el buffer, se envía a disco con una única operación de escritura; o, en caso necesario, se puede enviar el buffer a disco en cualquier momento.

Creación de Streams de salida con buffer
Para crear un stream BufferedOutput, primero se necesita un stream FileOutput normal; entonces se le añade un buffer al stream:

    FileOutputStream miFileStream;
   BufferdOutpurStream miBufferStream;
   // Obtiene un controlador de fichero
   miFileStream = new FileOutputStream( "/tmp/kk" );
   // Encadena un stream de salida con buffer
   miBufferStream = new BufferedOutputStream( miFileStream );

Lectura de un DataInputStream

2009-09-15T20:13:00.000-07:00

Lectura de un DataInputStream
Al acceder a un fichero como DataInputStream, se pueden utilizar los mismos métodos read() de los objetos FileInputStream. No obstante, también se tiene acceso a otros métodos diseñados para leer cada uno de los tipos de datos:

    byte readByte()
   int readUnsignedByte()
   short readShort()
   int readUnsignedShort()
   char readChar()
   int readInt()
   long readLong()
   float readFloat()
   double readDouble()
   String readLine()

Cada método leerá un objeto del tipo pedido.

Para el método String readLine(), se marca el final de la cadena con n, r, rn o con EOF.

Para leer un long, por ejemplo:

    long numeroSerie;
   ...
   numeroSerie = miDStream.readLong();

Objetos DataInputStream

2009-09-08T20:12:00.000-07:00

Objetos DataInputStream
Los objetos DataInputStream se comportan como los FileInputStream. Los streams de datos pueden leer cualquiera de las variables de tipo nativo, como floats, ints o chars. Generalmente se utilizan DataInputStream con ficheros binarios.

Apertura y cierre de DataInputStream
Para abrir y cerrar un objeto DataInputStream, se utilizan los mismos métodos que para FileInputStream:

DataInputStream miDStream;
FileInputStream miFStream;

// Obtiene un controlador de fichero
miFStream = new FileInputStream "/etc/ejemplo.dbf" );
//Encadena un fichero de entrada de datos
miDStream = new DataInputStream( miFStream );

// Ahora se pueden utilizar los dos streams de entrada para
// acceder al fichero (si se quiere...)
miFStream.read( b );
i = miDStream.readInt();

// Cierra el fichero de datos explícitamente
//Siempre se cierra primero el fichero stream de mayor nivel
miDStream.close();
miFStream.close();

Lectura de un FileInputStream

2009-08-28T20:12:00.000-07:00

Lectura de un FileInputStream
Una vez abierto el FileInputStream, se puede leer de él. El método read() tiene muchas opciones:

int read();

Lee un byte y devuelve -1 al final del stream.

int read( byte b[] );

Llena todo el array, si es posible. Devuelve el número de bytes leídos o -1 si se alcanzó el final del stream.

int read( byte b[],int offset,int longitud );

Lee longitud bytes en b comenzando por b[offset]. Devuelve el número de bytes leídos o -1 si se alcanzó el final del stream.

Cierre de FileInputStream
Cuando se termina con un fichero, existen dos opciones para cerrarlo: explícitamente, o implícitamente cuando se recicla el objeto (el garbage collector se encarga de ello).

Para cerrarlo explícitamente, se utiliza el método close():

    miFicheroSt.close();

Ejemplo: Visualización de un fichero
Si la configuración de la seguridad de Java permite el acceso a ficheros, se puede ver el contenido de un fichero en un objeto TextArea. El código siguiente contiene los elementos necesarios para mostrar un fichero:

    FileInputStream fis;
   TextArea ta;

   public void init() {
       byte b[] = new byte[1024];
       int i;

       // El buffer de lectura se debe hacer lo suficientemente grande
       // o esperar a saber el tamaño del fichero
       String s;

       try {
           fis = new FileInputStream( "/etc/kk" );
       } catch( FileNotFoundException e ) {
           /* Hacer algo */
           }

       try {
           i = fis.read( b );
       } catch( IOException e ) {
           /* Hacer algo */
           }

       s = new String( b,0 );
       ta = new TextArea( s,5,40 );
       add( ta );
       }

Hemos desarrollado un ejemplo, Agenda.java, en el que partimos de un fichero agenda que dispone de los datos que nosotros deseamos de nuestros amigos, como son: nombre, teléfono y dirección. Si tecleamos un nombre, buscará en el fichero de datos si existe ese nombre y presentará la información que se haya introducido. Para probar, intentar que aparezca la información de Pepe.

STREAMS DE ENTRADA

2009-08-25T20:11:00.000-07:00

STREAMS DE ENTRADA

Hay muchas clases dedicadas a la obtención de entrada desde un fichero. Este es el esquema de la jerarquía de clases de entrada por fichero:

Objetos FileInputStream
Los objetos FileInputStream típicamente representan ficheros de texto accedidos en orden secuencial, byte a byte. Con FileInputStream, se puede elegir acceder a un byte, varios bytes o al fichero completo.

Apertura de un FileInputStream
Para abrir un FileInputStream sobre un fichero, se le da al constructor un String o un objeto File:

    FileInputStream mi FicheroSt;
   miFicheroSt = new FileInputStream( "/etc/kk" );

También se puede utilizar:

    File miFichero FileInputStream miFicheroSt;
   miFichero = new File( "/etc/kk" );
   miFicheroSt = new FileInputStream(
   miFichero );

Comprobaciones y Utilidades

2009-08-15T20:10:00.000-07:00

Comprobaciones y Utilidades

Una vez creado un objeto File, se puede utilizar uno de los siguientes métodos para reunir información sobre el fichero:

Nombres de fichero

        String getName()
       String getPath()
       String getAbsolutePath()
       String getParent()
       boolean renameTo( File nuevoNombre )

Comprobaciones

        boolean exists()
       boolean canWrite()
       boolean canRead()
       boolean isFile()
       boolean isDirectory()
       boolean isAbsolute()

Información general del fichero

        long lastModified()
       long length()

Utilidades de directorio

        boolean mkdir()
       String[] list()

Vamos a desarrollar una pequeña aplicación que muestra información sobre los ficheros pasados como argumentos en la línea de comandos, InfoFichero.java :

import java.io.*;

class InfoFichero {

   public static void main( String args[] ) throws IOException {
       if( args.length > 0 )
           {
           for( int i=0; i < args.length; i++ )
               {
               File f = new File( args[i] );
               System.out.println( "Nombre: "+f.getName() );
               System.out.println( "Camino: "+f.getPath() );
               if( f.exists() )
                   {
                   System.out.print( "Fichero existente " );
                   System.out.print( (f.canRead() ?
                       " y se puede Leer" : "" ) );
                   System.out.print( (f.canWrite() ?
                       " y se puese Escribir" : "" ) );
                   System.out.println( "." );
                   System.out.println( "La longitud del fichero son "+
                       f.length()+" bytes" );
                   }
               else
                   System.out.println( "El fichero no existe." );
               }
           }
       else
           System.out.println( "Debe indicar un fichero." );
       }
   }

Creación de un objeto File

2009-08-10T20:10:00.000-07:00

Creación de un objeto File

Para crear un objeto File nuevo, se puede utilizar cualquiera de los tres constructores siguientes:

    File miFichero;
   miFichero = new File( "/etc/kk" );

    miFichero = new File( "/etc","kk" );

    File miDirectorio = new File( "/etc" );
   miFichero = new File( miDirectorio,"kk" );

El constructor utilizado depende a menudo de otros objetos File necesarios para el acceso. Por ejemplo, si sólo se utiliza un fichero en la aplicación, el primer constructor es el mejor. Si en cambio, se utilizan muchos ficheros desde un mismo directorio, el segundo o tercer constructor serán más cómodos. Y si el directorio o el fichero es una variable, el segundo constructor será el más útil.

FICHEROS

2009-08-05T20:09:00.000-07:00

FICHEROS

Todos los lenguajes de programación tienen alguna forma de interactuar con los sistemas de ficheros locales; Java no es una excepción.

Cuando se desarrollan applets para utilizar en red, hay que tener en cuenta que la entrada/salida directa a fichero es una violación de seguridad de acceso. Muchos usuarios configurarán sus navegadores para permitir el acceso al sistema de ficheros, pero otros no.

Por otro lado, si se está desarrollando una aplicación Java para uso interno, probablemente será necesario el acceso directo a ficheros.

Ficheros

Antes de realizar acciones sobre un fichero, necesitamos un poco de información sobre ese fichero. La clase File proporciona muchas utilidades relacionadas con ficheros y con la obtención de información básica sobre esos ficheros.

Clases comunes de Entrada/Salida

2009-07-29T20:09:00.000-07:00

Clases comunes de Entrada/Salida

Además de la entrada por teclado y salida por pantalla, se necesita entrada/salida por fichero, como son:

    FileInputStream
   DataInputStream
   FileOutputStream
   DataOutputStream

También existen otras clases para aplicaciones más específicas, que no vamos a tratar, por ser de un uso muy concreto:

    PipedInputStream
   BufferedInputStream
   PushBackInputStream
   StreamTokenizer
   PipedOutputStream
   BufferedOutputStream

ENTRADA/SALIDA ESTANDAR

2009-07-23T20:08:00.000-07:00

Los usuarios de Unix, y aquellos familiarizados con las líneas de comandos de otros sistemas como DOS, han utilizado un tipo de entrada/salida conocida comúnmente por entrada/salida estándar . El fichero de entrada estándar ( stdin ) es simplemente el teclado. El fichero de salida estándar ( stdout ) es típicamente la pantalla (o la ventana del terminal). El fichero de salida de error estándar ( stderr ) también se dirige normalmente a la pantalla, pero se implementa como otro fichero de forma que se pueda distinguir entre la salida normal y (si es necesario) los mensajes de error.

La clase System

Java tiene acceso a la entrada/salida estándar a través de la clase System . En concreto, los tres ficheros que se implementan son:

Stdin

System.in implementa stdin como una instancia de la clase InputStream . Con System.in , se accede a los métodos read() y skip( ). El método read() permite leer un byte de la entrada. skip( long n ) , salta n bytes de la entrada.

Stdout

System.out implementa stdout como una instancia de la clase PrintStream . Se pueden utilizar los métodos print() y println() con cualquier tipo básico Java como argumento.

Stderr

System.err implementa stderr de la misma forma que stdout. Como con System.out, se tiene acceso a los métodos de PrintStream.

Vamos a ver un pequeño ejemplo de entrada/salida en Java. El código siguiente, miType.java , reproduce, o funciona como la utilidad cat de Unix o type de DOS:

    import java.io.*;

   class miType {
       public static void main( String args[] ) throws IOException {
           int c;
           int contador = 0;

           while( (c = System.in.read() ) != 'n' )
               {
               contador++;
               System.out.print( (char)c );
               }
           System.out.println();    // Línea en blanco
           System.err.println( "Contados "+ contador +" bytes en total." );
           }
       }

Clases comunes de Entrada/Salida

2009-07-19T18:49:00.000-07:00

Además de la entrada por teclado y salida por pantalla, se necesita entrada/salida por fichero, como son:

FileInputStream
DataInputStream
FileOutputStream
DataOutputStream

También existen otras clases para aplicaciones más específicas, que no vamos a tratar, por ser de un uso muy concreto:

PipedInputStream
BufferedInputStream
PushBackInputStream
StreamTokenizer
PipedOutputStream
BufferedOutputStream

La clase System

2009-07-15T18:48:00.000-07:00

Java tiene acceso a la entrada/salida estándar a través de la clase System . En concreto, los tres ficheros que se implementan son:

Stdin
System.in implementa stdin como una instancia de la clase InputStream . Con System.in , se accede a los métodos read() y skip( ). El método read() permite leer un byte de la entrada. skip( long n ) , salta n bytes de la entrada.

Stdout
System.out implementa stdout como una instancia de la clase PrintStream . Se pueden utilizar los métodos print() y println() con cualquier tipo básico Java como argumento.

Stderr
System.err implementa stderr de la misma forma que stdout.

Como con System.out, se tiene acceso a los métodos de PrintStream.
Vamos a ver un pequeño ejemplo de entrada/salida en Java. El código siguiente,

reproduce, o funciona como la utilidad cat de Unix o type de DOS:
import java.io.*;
class miType {
public static void main( String args[] ) throws IOException {
int c;
int contador = 0;
while( (c = System.in.read() ) != 'n' )
{
contador++;
System.out.print( (char)c );
}
System.out.println(); // Línea en blanco
System.err.println( "Contados "+ contador +" bytes en total." );
}
}

ENTRADA/SALIDA ESTANDAR

2009-07-11T18:47:00.000-07:00

Los usuarios de Unix, y aquellos familiarizados con las líneas de comandos de otros sistemas como DOS, han utilizado un tipo de entrada/salida conocida comúnmente por entrada/salida estándar . El fichero de entrada estándar ( stdin ) es simplemente el teclado.

El fichero de salida estándar ( stdout ) es típicamente la pantalla (o la ventana del terminal). El fichero de salida de error estándar ( stderr ) también se dirige normalmente a la pantalla, pero se implementa como otro fichero de forma que se pueda distinguir entre la salida normal y (si es necesario) los mensajes de error.

PROPAGACION DE EXCEPCIONES II

2009-07-08T18:46:00.000-07:00

Cuando se crea una nueva excepción, derivando de una clase Exception ya existente, se puede cambiar el mensaje que lleva asociado. La cadena de texto puede ser recuperada a través de un método.

Normalmente, el texto del mensaje proporcionará información para resolver el problema o sugerirá una acción alternativa.

Por ejemplo:

class SinGasolina extends Exception {
SinGasolina( String s ) { // constructor
super( s );
}
....
// Cuando se use, aparecerá algo como esto
try {
if( j < 1 )
throw new SinGasolina( "Usando deposito de reserva" );
} catch( SinGasolina e ) {
System.out.println( o.getMessage() );
}
Esto, en tiempo de ejecución originaría la siguiente salida por pantalla:

> Usando deposito de reserva
Otro método que es heredado de la superclase Throwable es printStackTrace() . Invocando a este método sobre una excepción se volcará a pantalla todas las llamadas hasta el momento en donde se generó la excepción (no donde se maneje la excepción). Por ejemplo: // Capturando una excepción en un método
class testcap {
static int slice0[] = { 0,1,2,3,4 };
public static void main( String a[] ) {
try {
uno();
} catch( Exception e ) {
System.out.println( "Captura de la excepcion en main()" );
e.printStackTrace();
}
}
static void uno() {
try {
slice0[-1] = 4;
} catch( NullPointerException e ) {
System.out.println( "Captura una excepcion diferente" );
}
}
}
Cuando se ejecute ese código, en pantalla observaremos la siguiente salida: > Captura de la excepcion en main()
> java.lang.ArrayIndexOutOfBoundsException: -1
at testcap.uno(test5p.java:19)
at testcap.main(test5p.java:9)
Con todo el manejo de excepciones podemos concluir que proporciona un método más seguro para el control de errores, además de representar una excelente herramienta para organizar en sitios concretos todo el manejo de los errores y, además, que podemos proporcionar mensajes de error más decentes al usuario indicando qué es lo que ha fallado y por qué, e incluso podemos, a veces, recuperarnos de los errores.

La degradación que se produce en la ejecución de programas con manejo de excepciones está ampliamente compensada por las ventajas que representa en cuanto a seguridad de funcionamiento de esos mismos programas.

PROPAGACION DE EXCEPCIONES I

2009-07-04T18:45:00.000-07:00

La cláusula catch comprueba los argumentos en el mismo orden en que aparezcan en el programa. Si hay alguno que coincida, se ejecuta el bloque y sigue el flujo de control por el bloque finally (si lo hay) y concluye el control de la excepción.

Si ninguna de las cláusulas catch coincide con la excepción que se ha producido, entonces se ejecutará el código de la cláusula finally (en caso de que la haya). Lo que ocurre en este caso, es exactamente lo mismo que si la sentencia que lanza la excepción no se encontrase encerrada en el bloque try.

El flujo de control abandona este método y retorna prematuramente al método que lo llamó. Si la llamada estaba dentro del ámbito de una sentencia try, entonces se vuelve a intentar el control de la excepción, y así continuamente.

Veamos lo que sucede cuando una excepción no es tratada en la rutina en donde se produce. El sistema Java busca un bloque try..catch más allá de la llamada, pero dentro del método que lo trajo aquí. Si la excepción se propaga de todas formas hasta lo alto de la pila de llamadas sin encontrar un controlador específico para la excepción, entonces la ejecución se detendrá dando un mensaje. Es decir, podemos suponer que Java nos está proporcionando un bloque catch por defecto, que imprime un mensaje de error y sale.

No hay ninguna sobrecarga en el sistema por incorporar sentencias try al código. La sobrecarga se produce cuando se genera la excepción.

Hemos dicho ya que un método debe capturar las excepciones que genera, o en todo caso, declararlas como parte de su llamada, indicando a todo el mundo que es capaz de generar excepciones. Esto debe ser así para que cualquiera que escriba una llamada a ese método esté avisado de que le puede llegar una excepción, en lugar del valor de retorno normal. Esto permite al programador que llama a ese método, elegir entre controlar la excepción o propagarla hacia arriba en la pila de llamadas.

La siguiente línea de código muestra la forma general en que un método declara excepciones que se pueden propagar fuera de él: tipo_de_retorno( parametros ) throws e1,e2,e3 { }
Los nombres e1,e2,... deben ser nombres de excepciones, es decir, cualquier tipo que sea asignable al tipo predefinido Throwable . Observar que, como en la llamada al método se especifica el tipo de retorno, se está especificando el tipo de excepción que puede generar (en lugar de un objeto exception).

He aquí un ejemplo, tomado del sistema Java de entrada/salida:

byte readByte() throws IOException;
short readShort() throws IOException;
char readChar() throws IOException;
void writeByte( int v ) throws IOException;
void writeShort( int v ) throws IOException;
void writeChar( int v ) throws IOException;

Lo más interesante aquí es que la rutina que lee un char, puede devolver un char; no el entero que se requiere en C. C necesita que se devuelva un int, para poder pasar cualquier valor a un char, y además un valor extra (-1)

para indicar que se ha alcanzado el final del fichero. Algunas de las rutinas Java lanzan una excepción cuando se alcanza el fin del fichero.

En el siguiente diagrama se muestra gráficamente cómo se propaga la excepción que se genera en el código, a través de la pila de llamadas durante la ejecución del código:

finally

2009-07-01T18:44:00.000-07:00

Es el bloque de código que se ejecuta siempre, haya o no excepción. Hay una cierta controversia entre su utilidad, pero, por ejemplo, podría servir para hacer un log o un seguimiento de lo que está pasando, porque como se ejecuta siempre puede dejarnos grabado si se producen excepciones y nos hemos recuperado de ellas o no.

Este bloque finally puede ser útil cuando no hay ninguna excepción. Es un trozo de código que se ejecuta independientemente de lo que se haga en el bloque try.

Cuando vamos a tratar una excepción, se nos plantea el problema de qué acciones vamos a tomar. En la mayoría de los casos, bastará con presentar una indicación de error al usuario y un mensaje avisándolo de que se ha producido un error y que decida si quiere o no continuar con la ejecución del programa.

Por ejemplo, podríamos disponer de un diálogo como el que se presenta en el código siguiente:

public class DialogoError extends Dialog {
DialogoError( Frame padre ) {
super( padre,true );
setLayout( new BorderLayout() );
// Presentamos un panel con continuar o salir
Panel p = new Panel();
p.add( new Button( "¿Continuar?" ) );
p.add( new Button( "Salir" ) );
add( "Center",new Label(
"Se ha producido un error. ¿Continuar?" ) )
add( "South",p );
}
public boolean action( Event evt,Object obj ) {
if( "Salir".equals( obj ) )
{
dispose();
System.exit( 1 );
}
return false;
}
}
Y la invocación, desde algún lugar en que se suponga que se generarán errores, podría ser como sigue: try {
// Código peligroso
}
catch( AlgunaExcepcion e ) {
VentanaError = new DialogoError( this );
VentanaError.show();
}

catch

2009-06-26T18:43:00.002-07:00

Es el código que se ejecuta cuando se produce la excepción. Es como si dijésemos "controlo cualquier excepción que coincida con mi argumento".

En este bloque tendremos que asegurarnos de colocar código que no genere excepciones. Se pueden colocar sentencias catch sucesivas, cada una controlando una excepción diferente. No debería intentarse capturar todas las excepciones con una sola cláusula, como esta: catch( Excepcion e ) { ...
Esto representaría un uso demasiado general, podrían llegar muchas más excepciones de las esperadas.

En este caso es mejor dejar que la excepción se propague hacia arriba y dar un mensaje de error al usuario.

Se pueden controlar grupos de excepciones, es decir, que se pueden controlar, a través del argumento, excepciones semejantes.

Por ejemplo: class Limites extends Exception {}
class demasiadoCalor extends Limites {}
class demasiadoFrio extends Limites {}
class demasiadoRapido extends Limites {}
class demasiadoCansado extends Limites {}
.
.
.
try {
if( temp > 40 )
throw( new demasiadoCalor() );
if( dormir < 8 )
throw( new demasiado Cansado() );
} catch( Limites lim ) {
if( lim instanceof demasiadoCalor )
{
System.out.println( "Capturada excesivo calor!" );
return;
}
if( lim instanceof demasiadoCansado )
{
System.out.println( "Capturada excesivo cansancio!" );
return;
}
} finally
System.out.println( "En la clausula finally" );
La cláusula catch comprueba los argumentos en el mismo orden en que aparezcan en el programa. Si hay alguno que coincida, se ejecuta el bloque. El operador instanceof se utiliza para identificar exactamente cual ha sido la identidad de la excepción.

CAPTURAR EXCEPCIONES

2009-06-22T18:42:00.000-07:00

Las excepciones lanzadas por un método que pueda hacerlo deben recoger en bloque try/catch o try/finally .

int valor;
try {
for( x=0,valor = 100; x < 100; x ++ )
valor /= x;
}
catch( ArithmeticException e ) {
System.out.println( "Matemáticas locas!" );
}
catch( Exception e ) {
System.out.println( "Se ha producido un error" );
}

try
Es el bloque de código donde se prevé que se genere una excepción. Es como si dijésemos "intenta estas sentencias y mira a ver si se produce una excepción". El bloque try tiene que ir seguido, al menos, por una cláusula catch o una cláusula finally

CREAR EXCEPCIONES

2009-06-17T18:41:00.000-07:00

También podemos lanzar nuestras propias excepciones, extendiendo la clase System.exception . Por ejemplo, consideremos un programa cliente/servidor. El código cliente se intenta conectar al servidor, y durante 5 segundos se espera a que conteste el servidor.

Si el servidor no responde, el servidor lanzaría la excepción de time-out:

class ServerTimeOut

Exception extends Exception {}

public void conectame( String nombreServidor ) throws Exception {
int exito;
int puerto = 80;
exito = open( nombreServidor,puerto );
if( exito == -1 )
throw ServerTimeOutException;
}
Si se quieren capturar las propias excepciones, se deberá utilizar la sentencia try : public void encuentraServidor() {
...
try {
conectame( servidorDefecto );
catch( ServerTimeOutException e ) {
g.drawString(
"Time-out del Servidor, intentando alternativa",
5,5 );
conectame( servidorAlterno );
}
...
}

Cualquier método que lance una excepción también debe capturarla, o declararla como parte de la interface del método. Cabe preguntarse entonces, el porqué de lanzar una excepción si hay que capturarla en el mismo método. La respuesta es que las excepciones no simplifican el trabajo del control de errores. Tienen la ventaja de que se puede tener muy localizado el control de errores y no tenemos que controlar millones de valores de retorno, pero no van más allá.

EXCEPCIONES PREDEFINIDAS

2009-06-12T18:38:00.000-07:00

Las excepciones predefinidas y su jerarquía de clases es la que se muestra en la figura:

Los nombres de las excepciones indican la condición de error que representan.

Las siguientes son las excepciones predefinidas más frecuentes que se pueden encontrar:

ArithmeticException

Las excepciones aritméticas son típicamente el resultado de una división por 0: int i = 12 / 0;

NullPointerException

Se produce cuando se intenta acceder a una variable o método antes de ser definido: class Hola extends Applet {
Image img;
paint( Graphics g ) {
g.drawImage( img,25,25,this );
}
}
IncompatibleClassChangeException

El intento de cambiar una clase afectada por referencias en otros objetos, específicamente cuando esos objetos todavía no han sido recompilados.

ClassCastException
El intento de convertir un objeto a otra clase que no es válida. y = (Prueba)x; // donde
x no es de tipo Prueba

NegativeArraySizeException
Puede ocurrir si hay un error aritmético al intentar cambiar el tamaño de un array.

OutOfMemoryException

¡No debería producirse nunca! El intento de crear un objeto con el operador new ha fallado por falta de memoria. Y siempre tendría que haber memoria suficiente porque el garbage collector se encarga de proporcionarla al ir liberando objetos que no se usan y devolviendo memoria al sistema.

NoClassDefFoundException
Se referenció una clase que el sistema es incapaz de encontrar.

ArrayIndexOutOfBoundsException
Es la excepción que más frecuentemente se produce. Se genera al intentar acceder a un elemento de un array más allá de los límites definidos inicialmente para ese array.

UnsatisfiedLinkException

Se hizo el intento de acceder a un método nativo que no existe. Aquí no existe un método a.kk

class A {
native void kk();
}
InternalException

Este error se reserva para eventos que no deberían ocurrir. Por definición, el usuario nunca debería ver este error y esta excepción no debería lanzarse.

GENERAR EXCEPCIONES

2009-06-09T23:38:00.000-07:00

Cuando se produce un error se debería generar, o lanzar, una excepción. Para que un método en Java, pueda lanzar excepciones, hay que indicarlo expresamente.

void MetodoAsesino() throws

NullPointerException,CaidaException

Se pueden definir excepciones propias, no hay por qué limitarse a las predefinidas; bastará con extender la clase Exception y proporcionar la funcionalidad extra que requiera el tratamiento de esa excepción.

También pueden producirse excepciones no de forma explícita como en el caso anterior, sino de forma implícita cuando se realiza alguna acción ilegal o no válida.

Las excepciones, pues, pueden originarse de dos modos: el programa hace algo ilegal (caso normal), o el programa explícitamente genera una excepción ejecutando la sentencia throw (caso menos normal). La sentencia throw tiene la siguiente forma: throw ObtejoExcepction;
El objeto Objeto

Exception es un objeto de una clase que extiende la clase Exception .

El siguiente código de ejemplo origina una excepción de división por cero:

class melon {
public static void main( String[] a ) {
int i=0, j=0, k;
k = i/j; // Origina un error de division-by-zero
}
}

Si compilamos y ejecutamos esta aplicación Java, obtendremos la siguiente salida por pantalla:

> javac melon.java
> java melon
java.lang.ArithmeticException: / by zero
at melon.main(melon.java:5)

Las excepciones predefinidas, como ArithmeticException , se conocen como excepciones runtime. Actualmente, como todas las excepciones son eventos runtime, sería mejor llamarlas excepciones irrecuperables.

Esto contrasta con las excepciones que generamos explícitamente, que suelen ser mucho menos severas y en la mayoría de los casos podemos recuperarnos de ellas. Por ejemplo, si un fichero no puede abrirse, preguntamos al usuario que nos indique otro fichero; o si una estructura de datos se encuentra completa, podremos sobreescribir algún elemento que ya no se necesite.

Ejemplo de Excepciones

2009-06-06T23:33:00.000-07:00

// // HolaIte.java
// Copyright (c) 1996, Agustin Froufe
// Todos los derechos reservados.
// // No se asume ninguna responsabilidad por el uso o alteracion de este
// software. Este software se proporciona COMO ES, sin garantia de ningun
// tipo de su funcionamiento y en ningun caso sera el autor responsable de
// daños o perjuicios que se deriven del mal uso del software, aun cuando
// este haya sido notificado de la posibilidad de dicho daño.
// // Compilador: javac 1.0
// Autor: Agustin Froufe
// Creacion: 17-Sep-1996 06:03:59
// //--------------------------------------------------------------------------// Esta informacion no es necesariamente definitiva y esta sujeta a cambios// que pueden ser incorporados en cualquier momento, sin avisar.//--------------------------------------------------------------------------
import java.awt.*;import java.applet.Applet;
public class HolaIte extends Applet {
private int i = 0;
private String Saludos[] = { "Hola Mundo!", "HOLA Mundo!", "HOLA MUNDO!!" };

public void paint( Graphics g )
{
try {
g.drawString( Saludos[i],25,25 );
} catch( ArrayIndexOutOfBoundsException e )
{
g.drawString( "Saludos desbordado",25,25 );
} catch( Exception e )
{
// Cualquier otra excepción System.out.println( e.toString() );
} finally {
System.out.println( "Esto se imprime siempre!" );
} i++; } }
//------------------------------------------- Final del fichero HolaIte.java

MANEJO DE EXCEPCIONES

2009-06-02T23:32:00.000-07:00

Vamos a mostrar como se utilizan las excepciones, reconvirtiendo nuestro applet de saludo a partir de la versión iterativa de HolaIte.java : import java.awt.*;

import java.applet.Applet;
public class HolaIte extends Applet {
private int i = 0;
private String Saludos[] = {
"Hola Mundo!",
"HOLA Mundo!",
"HOLA MUNDO!!"
};
public void paint( Graphics g ) {
g.drawString( Saludos[i],25,25 );
i++;
}
}
Normalmente, un programa termina con un mensaje de error cuando se lanza una excepción. Sin embargo, Java tiene mecanismos para excepciones que permiten ver qué excepción se ha producido e intentar recuperarse de ella.
Vamos a reescribir el método paint() de nuestra versión iterativa del saludo: public void paint( Graphics g ) {
try {
g.drawString( Saludos[i],25,25 );
} catch( ArrayIndexOutOfBoundsException e ) {
g.drawString( "Saludos desbordado",25,25 );
} catch( Exception e ) {
// Cualquier otra excepción
System.out.println( e.toString() );
} finally {
System.out.println( "Esto se imprime siempre!" );
}
i++;
}

La palabra clave finally define un bloque de código que se quiere que sea ejecutado siempre, de acuerdo a si se capturó la excepción o no. En el ejemplo anterior, la salida en la consola, con i=4 sería: Saludos desbordado

¡Esto se imprime siempre!

USO DE CONVERSIONES

2009-05-28T23:31:00.000-07:00

Veamos un ejemplo de utilidad de estas funciones. En el applet Conversion.java , que se muestra en el código que sigue, se usan estas funciones para producir una salida útil en un programa, presentando las coordenadas en las que se ha hecho click con el botón del ratón. public class

Conversion extends Applet {
int RatonX = 25;
int RatonY = 25;
String Status = "Haz click con el ratón";

public void paint( Graphics g ) {
g.drawString( Status,RatonX,RatonY );
}

public boolean mouseDown( Event evt,int x,int y ) {
Integer X = new Integer( x );
Integer Y = new Integer( y );

RatonX = x;
RatonY = y;
Status = X.toString()+","+Y.toString();

repaint();
return true;
}
}

Operadores de Concatenación

2009-05-24T23:29:00.000-07:00

Hay que recordar que los operadores " + " y " += " también se pueden aplicar a cadenas. Ambos realizan una concatenación y están implementados con objetos StringBuffer.

Por ejemplo, la sentencia: String s = "¿Qué" + " tal ?";

es interpretada por el compilador como: String s = new StringBuffer().append( "¿Qué" ).append( " tal ?" ).toString();

y se marcaría el StringBuffer para borrarlo ya que el contenido pasa al objeto String. También, la sentencia: s += " por ahí!";

sería interpretada por el sistema como: String s = new StringBuffer().append( s ).append( " por ahí!" ).toString();

y volvería a marcar para borrar el nuevo StringBuffer.

Modificación del Contenido

2009-05-21T23:28:00.000-07:00

Para cambiar el contenido de un StringBuffer, se pueden utilizar dos métodos: append() e insert() .
En el ejemplo CadAppend.java , vemos el uso de estos dos métodos:

class CadAppend {
public static void main( String args[] ) {
StringBuffer str = new StringBuffer( "Hola" );
str.append( " Mundo" );
System.out.println( str );
}
}
En este otro ejemplo, CadInversa.java , mostramos un método muy simple que le da la vuelta a una

cadena:

class CadInversa {
public static String cadenaInversa( String fuente ) {
int longitud = fuente.length();

StringBuffer destino = new StringBuffer( longitud );
for( int i=(longitud-1); i >= 0; i-- )
destino.append( fuente.charAt( i ) );

return( destino.toString() );
}

public static void main( String args[] ) {
System.out.println( cadenaInversa( "Hola Mundo" ) );
}
}
Las funciones que cambian el tamaño son pues: StringBuffer append( Object obj );
StringBuffer append( String str );
StringBuffer append( char str[] );
StringBuffer append( char str[],int offset,int len );
StringBuffer append( boolean b );
StringBuffer append( int i );
StringBuffer append( long l );
StringBuffer append( float f );
StringBuffer append( double d );
StringBuffer append( char ch );
StringBuffer insert( int offset,Object obj );
StringBuffer insert( int offset,String str );
StringBuffer insert( int offset,char str[] );
StringBuffer insert( int offset,boolean b );
StringBuffer insert( int offset,int i );
StringBuffer insert( int offset,long l );
StringBuffer insert( int offset,float f );
StringBuffer insert( int offset,double d );
StringBuffer insert( int offset,char ch );

LA CLASE STRINGBUFFER

2009-05-18T23:27:00.000-07:00

Java posee gran capacidad para el manejo de cadenas dentro de sus clases String y StringBuffer . Un objeto String representa una cadena alfanumérica de un valor constante que no puede ser cambiada después de haber sido creada. Un objeto StringBuffer representa una cadena cuyo tamaño puede variar.

La clase StringBuffer dispone de muchos métodos para modificar el contenido de los objetos StringBuffer. Si el contenido de una cadena va a ser modificado en un programa, habrá que sacrificar el uso de objetos String en beneficio de StringBuffer, que aunque consumen más recursos del sistema, permiten ese tipo de manipulaciones.

Al estar la mayoría de las características de los StringBuffers basadas en su tamaño variable, se necesita un nuevo método de creación:

StringBuffer();

StringBuffer( int len );
StringBuffer( String str );

Se puede crear un StringBuffer vacío de cualquier longitud y también se puede utilizar un String como punto de partida para un StringBuffer.

StringBuffer Dos = new StringBuffer( 20 );
StringBuffer Uno = new StringBuffer( "Hola Mundo" );

Cambio de Tamaño

2009-05-15T23:27:00.000-07:00

El cambio de tamaño de un StringBuffer necesita varias funciones específicas para manipular el tamaño de las cadenas:

int length();

char charAt( int index );
void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin );
String toString();
void setLength( int newlength );
void setCharAt( int index,char ch );
int capacity();
void ensureCapacity( int minimum );
void copyWhenShared();

Obervar que una de las funciones devuelve una cadena constante normal de tipo String.

Este objeto se puede usar con cualquier función String, como por ejemplo, en las funciones de comparación.

Funciones ValueOf

2009-05-12T23:26:00.000-07:00

La clase String posee numerosas funciones para transformar valores de otros tipos de datos a su representación como cadena.

Todas estas funciones tienen el nombre de valueOf , estando el método sobrecargado para todos los tipos de datos básicos.

Veamos un ejemplo de su utilización:

String Uno = new String( "Hola Mundo" );
float f = 3.141592;
String PI = Uno.valueOf( f );
String PI = String.valueOf( f ); // Mucho más correcto

Funciones de Conversión String valueOf( boolean b );

String valueOf( int i );
String valueOf( long l );
String valueOf( float f );
String valueOf( double d );
String valueOf( Object obj );
String valueOf( char data[] );
String valueOf( char data[],int offset,int count );

Usa arrays de caracteres para la cadena. String copyValueOf( char data[] );
String copyValueOf( char data[],int offset,int count );
Crea un nuevo array equivalente para la cadena.

Funciones de Comparación de Subcadenas

2009-05-09T23:25:00.000-07:00

boolean regionMatch( int thisoffset,String s2,int s2offset,int len );
boolean regionMatch( boolean ignoreCase,int thisoffset,String s2,
int s2offset,int 1 );

Comprueba si una región de esta cadena es igual a una región de otra cadena. boolean startsWith

( String prefix );

boolean startsWith( String prefix,int offset );
boolean endsWith( String suffix );
Devuelve si esta cadena comienza o termina con un cierto prefijo o sufijo comenzando en un determinado desplazamiento. int indexOf( int ch );
int indexOf( int ch,int fromindex );
int lastIndexOf( int ch );
int lastIndexOf( int ch,int fromindex );
int indexOf( String str );
int indexOf( String str,int fromindex );
int lastIndexOf( String str );
int lastIndexOf( String str,int fromindex );
Devuelve el primer/último índice de un carácter/cadena empezando la búsqueda a partir de un determinado desplazamiento. String substring( int beginindex );
String substring( int beginindex,int endindex );
String concat( String str );
String replace( char oldchar,char newchar );
String toLowerCase();
String toUpperCase();
String trim();

Ajusta los espacios en blanco al comienzo y al final de la cadena.

void getChars( int srcBegin,int srcEnd,char dst[],int dstBegin );
void getBytes( int srcBegin,int srcEnd,byte dst[],int dstBegin );
String toString();
char toCharArray();
int hashCode();

LA CLASE STRING

2009-05-06T23:24:00.000-07:00

Los Strings son objetos constantes y por lo tanto muy baratos para el sistema. La mayoría de las funciones relacionadas con cadenas esperan valores String como argumentos y devuelven valores String.

Hay que tener en cuenta que las funciones estáticas no consumen memoria del objeto, con lo cual es más conveniente usar Character que char. No obstante, char se usa, por ejemplo, para leer ficheros que están escritos desde otro lenguaje.

Existen muchos constructores para crear nuevas cadenas: String();

String( String str );
String( char val[] );
String( char val[],int offset,int count );
String( byte val[],int hibyte );
String( byte val[],int hibyte,int offset,int count );

Tal como uno puede imaginarse, las cadenas pueden ser muy complejas, existiendo muchas funciones muy útiles para trabajar con ellas y, afortunadamente, la mayoría están codificadas en la clase String .

Funciones Básicas

La primera devuelve la longitud de la cadena y la segunda devuelve el carácter que se encuentra en la posición que se indica en indice :
int length();
char charAt( int indice );
Funciones de Comparación de Strings
boolean equals( Object obj );
boolean equalsIgnoreCase( Object obj );
Lo mismo que equals() pero no tiene en cuenta mayúsculas o minúsculas. int compareTo( String str2 );

Devuelve un entero menor que cero si la cadena es léxicamente menor que str2 . Devuelve cero si las dos cadenas son léxicamente iguales y un entero mayor que cero si la cadena es léxicamente mayor que str2 .

LA CLASE BOOLEAN

2009-05-02T11:21:00.000-07:00

Los valores boolean también tienen su tipo asociado Boolean , aunque en este caso hay menos métodos implementados que para el resto de las clases numéricas.

Declaraciones

La primera sentencia creará una variable boolean y la segunda un objeto Boolean:
boolean b;
Boolean B;
Valores de Boolean
Boolean.TRUE;
Boolean.FALSE;

Métodos de Boolean

boolean B.booleanValue();
String B.toString();
boolean B.equals( Object obj );

LA CLASE LONG

2009-04-29T11:20:00.000-07:00

Cada tipo numérico tiene su propia clase de objetos. Así el tipo long tiene el objeto Long . De la misma forma que con la clase Character , se han codificado muchas funciones útiles dentro de los métodos de la clase Long .

Declaraciones

La primera sentencia creará una variable long y la segunda un objeto Long:

long l;
Long L;
Valores de Long
Long.MIN_VALUE;
Long.MAX_VALUE;

Métodos de Long

String Long.toString( long l,int base );
String Long.toString( long l );
long L.parseLong( String s,int base );
long L.parseLong( String s );
Long Long.valueOf( String s,int base );
Long Long.valueOf( String s );
int L.intValue();
long L.longValue();
float L.floatValue();
double L.doubleValue();
String L.toString();
int L.hashCode();
boolean L.equals( Object obj );

En los métodos toString() , parseInt() y valueOf() que no se especifica la base sobre la que se trabaja, se asume que es base 10 .

LA CLASE INTEGER

2009-04-26T11:20:00.000-07:00

Cada tipo numérico tiene su propia clase de objetos. Así el tipo int tiene el objeto Integer . De la misma forma que con la clase Character , se han codificado muchas funciones útiles dentro de los métodos de la clase Integer .

Declaraciones

La primera sentencia creará una variable int y la segunda un objeto Integer:

Integer.MIN_VALUE;
Integer.MAX_VALUE;
Valores de Integer
Integer.MIN_VALUE;
Integer.MAX_VALUE;

Métodos de Integer

String Integer.toString( int i,int base );
String Integer.toString( int i );
int I.parseInt( String s,int base );
int I.parseInt( String s );
Integer Integer.valueOf( String s,int base );
Integer Integer.valueOf( String s );
int I.intValue();
long I.longValue();
float I.floatValue();
double I.doubleValue();
String I.toString();
int I.hashCode();
boolean I.equals( Object obj );

LA CLASE DOUBLE

2009-04-23T11:19:00.000-07:00

Cada tipo numérico tiene su propia clase de objetos. Así el tipo double tiene el objeto Double . De la misma forma que con la clase Character , se han codificado muchas funciones útiles dentro de los métodos de la clase Double .

Declaraciones

La primera sentencia creará una variable double y la segunda un objeto Double:

double d;
Double D;
Valores de Double
Double.POSITIVE_INFINITY
Double.NEGATIVE_INFINITY
Double.NaN
Double.MAX_VALUE
Double.MIN_VALUE
Métodos de Double
D.isNaN();
Double.isNaN( d );
D.isInfinite();
Double.isInfinite( d );
boolean D.equals();
String D.toString();
int D.intValue();
long D.longValue();
float D.floatValue();
double D.doubleValue();
int i = D.hashCode();
Double V.valueOf( String s );
long l = Double.doubleToLongBits( d );
double d = Double.longBitsToDouble( l );

LA CLASE FLOAT

2009-04-20T11:18:00.000-07:00

Cada tipo numérico tiene su propia clase de objetos. Así el tipo float tiene el objeto Float . De la misma forma que con la clase Character , se han codificado muchas funciones útiles dentro de los métodos de la clase Float .

Declaraciones

La primera sentencia creará una variable float y la segunda un objeto Float:

float f;
Float F;
Valores de Float
Float.POSITIVE_INFINITY
Float.NEGATIVE_INFINITY
Float.NaN
Float.MAX_VALUE
Float.MIN_VALUE
Conversiones de Clase/Cadena
String s = Float.toString( f );
f = Float.valueOf( "3.14" );
Comprobaciones
boolean b = Float.isNaN( f );
boolean b = Float.isInfinite( f );
La función isNaN() comprueba si f es un No-Número .

Un ejemplo de no-número es raiz cuadrada de -2. Conversiones de Objetos
Float F = new Float( Float.PI );
String s = F.toString();
int i = F.intValue();
long l = F.longValue();
float F = F.floatValue();
double d = F.doubleValue();

Otros Métodos

int i = F.hashCode();
boolean b = F.equals( Object obj );
int i = Float.floatToIntBits( f );
float f = Float.intBitsToFloat( i );

LA CLASE CHARACTER

2009-04-17T11:17:00.000-07:00

Al trabajar con caracteres se necesitan muchas funciones de comprobación y traslación. Estas funciones están empleadas en la clase Character . De esta clase sí que se pueden crear instancias, al contrario que sucede con la clase Math .

Declaraciones
La primera sentencia creará una variable carácter y la segunda un objeto Character:

char c;
Character C;
Comprobaciones booleanas
Character.isLowerCase( c )
Character.isUpperCase( c )
Character.isDigit( c )
Character.isSpace( c )

En este caso, si tuviésemos un objeto Character C , no se podría hacer C.isLowerCase , porque no se ha hecho un new de Character.

Estas funciones son estáticas y no conocen al objeto, por eso hay que crearlo antes.

Traslaciones de caracteres

char c2 = Character.toLowerCase( c );
char c2 = Character.toUpperCase( c );
Traslaciones de carácter/dígito
int i = Character.digit( c,base );
char c = Character.forDigit( i,base );
Métodos de la clase Character
C = new Character( 'J' );
char c = C.charValue();
String s = C.toString();

LA CLASE MATH

2009-04-14T11:16:00.000-07:00

La clase Math representa la librería matemática de Java. Las funciones que contiene son las de todos los lenguajes, parece que se han metido en una clase solamente a propósito de agrupación, por eso se encapsulan en Math, y lo mismo sucede con las demás clases que corresponden a objetos que tienen un tipo equivalente (Character, Float, etc.). El constructor de la clase es privado, por los que no se pueden crear instancias de la clase. Sin embargo, Math es public para que se pueda llamar desde cualquier sitio y static para que no haya que inicializarla.
Funciones matemáticas

Si se importa la clase, se tiene acceso al conjunto de funciones matemáticas estándar:

Math.abs( x ) para int, long, float y double
Math.sin( double )
Math.cos( double )
Math.tan( double )
Math.asin( double )
Math.acos( double )
Math.atan( double )
Math.atan2( double,double )
Math.exp( double )
Math.log( double )
Math.sqrt( double )
Math.ceil( double )
Math.floor( double )
Math.rint( double )
Math.pow( a,b )
Math.round( x ) para double y float
Math.random() devuelve un double
Math.max( a,b ) para int, long, float y double
Math.min( a,b ) para int, long, float y double
Math.E para la base exponencial
Math.PI para PI

He aquí un ejemplo, Mates.java , de uso de algunas funciones de la clase Math:

class Mates {
public static void main( String args[] ) {
int x;
double rand,y,z;
float max;

rand = Math.random();
x = Math.abs( -123 );
y = Math.round( 123.567 );
z = Math.pow( 2,4 );
max = Math.max( (float)1e10,(float)3e9 );

System.out.println( rand );
System.out.println( x );
System.out.println( y );
System.out.println( z );
System.out.println( max );
}
}

La marca applet en HTML

2009-04-11T11:15:00.000-07:00

El visualizador de applets (appletviewer) es una aplicación que permite ver en funcionamiento applets, sin necesidad de la utilización de un navegador World-Wide-Web como HotJava,

Microsoft Explorer o Nescape. En adelante, recurriremos muchas veces a él, ya que el objetivo del tutorial es el lenguaje Java.
Applet

La definición más extendida de applet, muy bien resumida por Patrick Naughton, indica que un applet es "una pequeña aplicación accesible en un servidor Internet, que se transporta por la red, se instala automáticamente y se ejecuta in situ como parte de un documento web". Claro que así la definición establece el entorno (Internet, Web, etc.). En realidad, un applet es una aplicación pretendidamente corta (nada impide que ocupe más de un gigabyte, a no ser el pensamiento de que se va a transportar por la red y una mente sensata) basada en un formato gráfico sin representación independiente: es decir, se trata de un elemento a embeber en otras aplicaciones; es un componente en su sentido estricto.

Un ejemplo en otro ámbito de cosas podría ser el siguiente: Imaginemos una empresa, que cansada de empezar siempre a codificar desde cero, diseña un formulario con los datos básicos de una persona (nombre, dirección, etc.). Tal formulario no es un diálogo por sí mismo, pero se podría integrar en diálogos de clientes, proveedores, empleados, etc. El hecho de que se integre estática (embebido en un ejecutable) o dinámicamente (intérpretes, DLLs, etc.) no afecta en absoluto a la esencia de su comportamiento como componente con que construir diálogos con sentido autónomo.

Pues bien, así es un applet. Lo que ocurre es que, dado que no existe una base adecuada para soportar aplicaciones industriales Java en las que insertar nuestras miniaplicaciones (aunque todo se andará), los applets se han construido mayoritariamente, y con gran acierto comercial (parece), como pequeñas aplicaciones interactivas, con movimiento, luces y sonido... en Internet.
Llamadas a Applets con appletviewer

Un applet es una mínima aplicación Java diseñada para ejecutarse en un navegador Web. Por tanto, no necesita preocuparse por un método main() ni en dónde se realizan las llamadas. El applet asume que el código se está ejecutando desde dentro de un navegador.

El appletviewer se asemeja al mínimo navegador. Espera como argumento el nombre del fichero html que debe cargar, no se le puede pasar directamente un programa Java.

Este fichero html debe contener una marca que especifica el código que cargará el appletviewer:

El appletviewer crear un espacio de navegación, incluyendo un área gráfica, donde se ejecutará el applet, entonces llamará a la clase applet apropiada. En el ejemplo anterior, el appletviewer cargará una clase de nombre HolaMundo y le permitirá trabajar en su espacio gráfico.

UN APPLET BASICO

2009-04-08T11:14:00.000-07:00

Vamos a comenzar la creación del código fuente del un applet que satisfaga nuestras necesidades.

Recordamos que Java utiliza la extensión .java para designar los ficheros fuente. HolaMundo

A continuación está el código fuente del applet HolaMundo, que es la versión applet de la mínima aplicación Java que antes habíamos escrito. Guardar este código en un fichero fuente Java como

HolaMundo.java .
//
// Applet HolaMundo de ejemplo
//
import java.awt.Graphics;
import java.applet.Applet;
public class HolaMundo extends Applet {
public void paint( Graphics g ) {
g.drawString( "Hola Mundo!",25,25 ) ;
}
}

Componentes básicos de un Applet
El lenguaje Java implementa un modelo de Programación Orientada a Objetos. Los objetos sirven de bloques centrales de construcción de los programas Java. De la misma forma que otros lenguajes de programación, Java tiene variables de estado y métodos.
Veamos como se descompone un applet en sus piezas/objetos:

/*
Sección de importaciones
*/
public class NombreDelNuevoApplet extends Applet {
/*
Aquí se declaran las variables de estado (public y private)
*/

/*
Los métodos para la interacción con los objetos se
declaran y definen aquí
*/
public void MetodoUno( parámetros ) {
/*
Aquí viene para cada método, el código Java que
desempeña la tarea.
Qué código se use depende del applet
*/
}
}

Para HolaMundo, se importan las dos clases que necesita. No hay variables de estado, y sólo se tiene que definir un método para que el applet tenga el comportamiento esperado. Clases incluidas

El comando import carga otras clases dentro de nuestro código fuente. El importar una clase desde un paquete de Java hace que esa clase importada esté disponible para todo el código incluido en el fichero fuente Java que la importa. Por ejemplo, en el applet HolaMundo se importa la clase java.awt.Graphics , y podremos llamar a los métodos de esta clase desde cualquier método de nuestro programa que se encuentre en el fichero HolaMundo.java . Esta clase define una área gráfica y métodos para poder dibujar dentro de ella. La función paint() declara a g como un objeto de tipo Graphics ; luego, paint() usa el método drawString() de la clase Graphics para generar su salida. La clase Applet

Se puede crear una nueva clase, en este caso HolaMundo , extendiendo la clase básica de Java: Applet . De esta forma, se hereda todo lo necesario para crear un applet. Modificando determinados métodos del applet, podemos lograr que lleve a cabo las funciones que deseamos.
import java.applet.Applet;
. . .
public class HolaMundo extends Applet {
Métodos de Applet
La parte del applet a modificar es el método paint() .

En la clase Applet , se llama al método paint() cada vez que el método arranca o necesita ser refrescado, pero no hace nada.

En nuestro caso, lo que hacemos es:

public void paint( Graphics g ) {
g.drawString( "Hola Mundo!",25,25 );
}

De acuerdo a las normas de sobrecarga, se ejecutará este último paint() y no el paint() vacío de la clase Applet . Luego, aquí se ejecuta el método drawString() , que le dice al applet cómo debe aparecer un texto en el área de dibujo.
Otros métodos básicos para dibujar son: drawLine( int x1,int y1,int x2,int y2 )
drawRect( int x,int y,int ancho,int alto )
drawOval( int x,int y,int ancho,int alto )
Tanto para drawRect() como para drawOval() , las coordenadas ( x,y ) son la esquina superior izquierda del rectángulo (para drawOval, el óvalo es encajado en el rectángulo que lo circunscribe).

COMPILACION Y EJECUCION DE HOLA MUNDO II

2009-04-05T11:13:00.000-07:00

Ejecución

Para ejecutar la aplicación HolaMundoApp, hemos de recurrir al intérprete java , que también se encuentra en el directorio bin , bajo el directorio java . Se ejecutará la aplicación con la línea: %java

HolaMundoApp

y debería aparecer en pantalla la respuesta de Java: %Hola Mundo!

El símbolo % representa al prompt del sistema, y lo utilizaremos para presentar las respuestas que nos ofrezca el sistema como resultado de la ejecución de los comandos que se indiquen en pantalla o para indicar las líneas de comandos a introducir.

Problemas de compilación

A continuación presentamos una lista de los errores más frecuentes que se presentan a la hora de compilar un fichero con código fuente Java, nos basaremos en errores provocados sobre nuestra mínima aplicación Java de la sección anterior, pero podría generalizarse sin demasiados problemas.

%javac: Command not found

No se ha establecido correctamente la variable PATH del sistema para el compilador javac . El compilador javac se encuentra en el directorio bin , que cuelga del directorio java , que cuelga del directorio donde se haya instalado el JDK (Java Development Kit). %HolaMundoApp.java:3: Method printl(java.lang.String) not found in class java.io.PrintStream. System.out.printl( "HolaMundo!); ^

Error tipográfico, el método es println no printl. %In class HolaMundoApp: main must be public and static

Error de ejecución, se olvidó colocar la palabra static en la declaración del método main de la aplicación.

%Can´t find class HolaMundoApp

Este es un error muy sutil. Generalmente significa que el nombre de la clase es distinto al del fichero que contiene el código fuente, con lo cual el fichero nombre_fichero.class que se genera es diferente del que cabría esperar. Por ejemplo, si en nuestro fichero de código fuente de nuestra aplicación HolaMundoApp.java colocamos en vez de la declaración actual de la clase HolaMundoApp , la línea: class HolaMundoapp {
se creará un fichero HolaMundoapp.class , que es diferente del HolaMundoApp.class , que es el nombre esperado de la clase; la diferencia se encuentra en la a minúscula y mayúscula.

COMPILACION Y EJECUCION DE HOLA MUNDO

2009-04-02T11:12:00.000-07:00

Vamos a ver a continuación como podemos ver el resultado de nuestra primera aplicación Java en pantalla. Generaremos un fichero con el código fuente de la aplicación, lo compilaremos y utilizaremos el intérprete java para ejecutarlo.

Ficheros Fuente Java

Los ficheros fuente en Java terminan con la extensión " .java ". Crear un fichero utilizando cualquier editor de texto ascii que tenga como contenido el código de las ocho líneas de nuestra mínima aplicación, y salvarlo en un fichero con el nombre de HolaMundoApp.java . Para crear los ficheros con código fuente Java no es necesario un procesador de textos, aunque puede utilizarse siempre que tenga salida a fichero de texto plano o ascii, sino que es suficiente con cualquier otro editor.

Compilación

El compilador javac se encuentra en el directorio bin por debajo del directorio java , donde se haya instalado el JDK. Este directorio bin , si se han seguido las instrucciones de instalación, debería formar parte de la variable de entorno PATH del sistema. Si no es así, tendría que revisar la Instalación del JDK . El compilador de Java traslada el código fuente Java a byte-codes, que son los componentes que entiende la Máquina Virtual Java que está incluida en los navegadores con soporte Java y en appletviewer.

Una vez creado el fichero fuente HolaMundoApp.java, se puede compilar con la línea siguiente:

%javac HolaMundoApp.java

Si no se han cometido errores al teclear ni se han tenido problemas con el path al fichero fuente ni al compilador, no debería aparecer mensaje alguno en la pantalla, y cuando vuelva a aparecer el prompt del sistema, se debería ver un fichero HolaMundoApp.class nuevo en el directorio donde se encuentra el fichero fuente.

Si ha habido algún problema, en Problemas de compilación al final de esta sección, hemos intentado reproducir los que más frecuentemente se suelen dar, se pueden consultar por si pueden aportar un poco de luz al error que haya aparecido.

UNA MINIMA APLICACION

2009-03-30T17:59:00.000-07:00

La aplicación más pequeña posible es la que simplemente imprimir un mensaje en la pantalla. Tradicionalmente, el mensaje suele ser "Hola Mundo!". Esto es justamente lo que hace el siguiente fragmento de código:

//
// Aplicación HolaMundo de ejemplo
//
class HolaMundoApp {
public static void main( String args[] ) {
System.out.println( "Hola Mundo!" ) ;
}
}
HolaMundo
Vamos ver en detalle la aplicación anterior, línea a línea. Esas líneas de código contienen los componenetes mínimos para imprimir Hola Mundo! en la pantalla. //
// Aplicación HolaMundo de ejemplo
//

Estas tres primera líneas son comentarios. Hay tres tipos de comentarios en Java, // es un comentario orientado a línea. class HolaMundoApp {
Esta línea declara la clase HolaMundoApp . El nombre de la clase especificado en el fichero fuente se utiliza para crear un fichero nombredeclase.class en el directorio en el que se compila la aplicación. En nuestro caso, el compilador creará un fichero llamado HolaMundoApp.class. public static void main( String args[] )

{
Esta línea especifica un método que el intérprete Java busca para ejecutar en primer lugar. Igual que en otros lenguajes, Java utiliza una palabra clave main para especificar la primera función a ejecutar. En este ejemplo tan simple no se pasan argumentos.
public significa que el método main puede ser llamado por cualquiera, incluyendo el intérprete Java.

static es una palabra clave que le dice al compilador que main se refiere a la propia clase HolaMundoApp y no a ninguna instancia de la clase. De esta forma, si alguien intenta hacer otra instancia de la clase, el método main no se instanciaría.
void indica que main no devuelve nada. Esto es importante ya que Java realiza una estricta comprobación de tipos, incluyendo los tipos que se ha declarado que devuelven los métodos.
args[] es la declaración de un array de Strings. Estos son los argumentos escritos tras el nombre de la clase en la línea de comandos: %java HolaMundoApp arg1 arg2 ...
System.out.println( "Hola Mundo!" );
Esta es la funcionalidad de la aplicación. Esta línea muestra el uso de un nombre de clase y método. Se usa el método println() de la clase out que está en el paquete System .
El método println() toma una cadena como argumento y la escribe en el stream de salida estándar; en este caso, la ventana donde se lanza la aplicación. }
}

Finalmente, se cierran las llaves que limitan el método main() y la clase HolaMundoApp .

Referencias y Listas Segunda Parte

2009-03-27T17:57:00.000-07:00

Revisemos pues el código de nuestro Hotel, ahora Hotel3.java , que será prácticamente el mismo que en el caso de los arrays:

public class Hotel3

{
// Número de habitaciones por ala
public static final int habPorAla = 12;
public static void main( String args[] ) {
ListaEnlazada llaveMaestra; // paso 1
llaveMaestra = new ListaEnlazada(); // pasos 2-5
int numPiso = 1;
for( int i=0; i < habPorAla; i++ ) // pasos 6-9
llaveMaestra.insertAt( i,
new Habitacion( numPiso * 100 + i,
( 0 == (i%2)) ? 2 : 1 );
for( int i=0; i < habPorAla; i++ ) // pasos 10-12
( (Habitacion)llaveMaestra.getAt(i) ).printData();
}
}
El paso 1 es la llave maestra de la lista. Está representada por una lista genérica; es decir, una lista de llaves que cumple la convención que nosotros hemos establecido. Podríamos acelerar el tiempo de compilación metiendo la lista genérica ListaEnlazada dentro de una ListaEnlazadaHabitacion .
Los pasos 2 a 5 son equivalentes a los del primer ejemplo. Construimos e inicializamos una nueva ListaEnlazada , que usaremos como juego de llaves maestras.
Los pasos 6 a 9 son funcionalmente idénticos a los del ejemplo anterior con arrays, pero con diferente sintaxis. En Java, los arrays y el operador [] son internos del lenguaje. Como Java no soporta la sobrecarga de operadores por parte del usuario, tenemos que usarlo siempre en su forma normal.

La ListaEnlazada proporciona el método insertAt() que coge el índice en la lista, donde el nuevo nodo ha de ser insertado, como primer argumento. El segundo argumento es el objeto que será almacenado en la lista. Obsérvese que no es necesario colocar moldeo alguno para hacer algo a una clase descendiente que depende de uno de sus padres.

Los pasos 10 a 12 provocan la misma salida que los pasos 10 y 11 del ejemplo con arrays. El paso 10 coge la llave del juego que se indica en el método getAt() . En este momento, el sistema no sabe qué datos contiene la llave, porque el contenido de la habitación es genérico. Pero nosotros sí sabemos lo que hay en la lista, así que informamos al sistema haciendo un moldeado a la llave de la habitación (este casting generará un chequeo en tiempo de ejecución por el compilador, para asegurarse de que se trata de una Habitacion ). El paso 12 usa la llave para imprimir la información.

REFERENCIAS Y LISTAS

2009-03-24T17:56:00.000-07:00

Hay gente que piensa que como Java no dispone de punteros, resulta demasiado complejo construir listas enlazadas, árboles binarios y grafos. Vamos a demostrar que quien así piense está bastante equivocado.

Retomemos el ejemplo de los arrays, y en vez de éstos vamos a usar una lista doblemente enlazada. El paquete de la lista simple se compone de dos clases. Cada elemento de la lista es un NodoListaEnlazada , NodoListaEnlazada.java :

public class NodoListaEnlazada

{
private NodoListaEnlazada siguiente;
private NodoListaEnlazada anterior;
private Object datos;
// . . .
}

Cada NodoListaEnlazada contiene una referencia a su nodo precedente en la lista y una referencia al nodo que le sigue. También contiene una referencia genérica a cualquier clase que se use para proporcionar acceso a los datos que el usuario proporcione.
La lista enlazada, ListaEnlazada.java , contiene un nodo principio-fin y un contador para el número de nodos en la lista:

public class ListaEnlazada

{
public NodoListaEnlazada PrincipioFin;
private int numNodos;
// . . .
}

El nodo especial PrincipioFin es sencillo, para simplificar el código. El contador se usa para optimizar los casos más habituales.

REFERENCIAS Y ARRAYS

2009-03-21T17:55:00.000-07:00

Como en C y C++, Java dispone de arrays de tipos primitivos o de clases. Los arrays en C y C++ son básicamente un acompañante para los punteros. En Java, sin embargo, son ciudadanos de primera clase.

Vamos a expandir nuestro hotel creando todo un ala de habitaciones, Hotel2.java . Crearemos un juego de llaves maestras y luego construiremos las habitaciones: public class Hotel2

{
// Número de habitaciones por ala
public static final int habPorAla = 12;
public static void main( String args[] ) {
Habitacion llavesMaestras[]; // paso 1
llavesMaestras = new Habitacion[ habPorAla ]; // pasos 2-5
// ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
// A B, C, D y E
int numPiso = 1;
for( int i=0; i < habPorAla; i++ ) // pasos 6-9
llavesMaestras[ i ] = new Habitacion( numPiso * 100 + i,
( 0 == (i%2)) ? 2 : 1 );
for( int i=0; i < habPorAla; i++ ) // pasos 10-11
llavesMaestras[i].printData();
}
}

Cada paso en el ejemplo es semejante al que ya vimos antes. El paso 1 especifica que el juego de llaves maestras es un grupo de llaves de habitaciones.
Los pasos 2 a 5 son, en este caso, la parte principal. En lugar de crear una habitación, el gerente ordena construir un grupo contiguo de habitaciones. El número de llaves se especifica entre corchetes y todas se crean en blanco.
Los pasos 6 a 9 son idénticos a los pasos 2 a 5 del ejemplo anterior, excepto en que en este caso todas las llaves pasan a formar parte del juego maestro. Los números de piso se dan en miles para que cuando se creen las habitaciones, todas tengan el mismo formato. También todas las habitaciones de número par tienen una sola cama, mientras que las habitaciones impares tendrán dos camas.
Los pasos 10 y 11 nos permiten obtener información de cada una de las habitaciones.

REFERENCIAS

2009-03-18T17:55:00.000-07:00

Las referencias en Java no son punteros ni referencias como en C++. Este hecho crea un poco de confusión entre los programadores que llegan por primera vez a Java. Las referencias en Java son identificadores de instancias de las clases Java. Una referencia dirige la atención a un objeto de un tipo específico. No tenemos por qué saber cómo lo hace ni necesitamos saber qué hace ni, por supuesto, su implementación.
Pensemos en una referencia como si se tratase de la llave electrónica de la habitación de un hotel. Vamos a utilizar precisamente este ejemplo del Hotel para demostrar el uso y la utilización que podemos hacer de las referencias en Java. Primero crearemos la clase Habitacion , implementada en el fichero Habitacion.java , mediante instancias de la cual construiremos nuestro Hotel: public class Habitacion {
private int numHabitacion;
private int numCamas;
public Habitacion() {
habitacion( 0 );
}
public Habitacion( int numeroHab ) {
habitacion( numeroHab );
}
public Habitacion( int numeroHab,int camas ) {
habitacion( numeroHab );
camas( camas );
}
public synchornized int habitacion() {
return( numHabitacion );
}
public synchronized void habitacion( int numeroHab ) {
numHabitacion = numeroHab;
}
public synchronized int camas() {
return( camas );
}
public syncronized void camas( int camas ) {
numCamas = camas;
}
}
El código anterior sería el corazón de la aplicación. Vamos pues a construir nuestro Hotel creando Habitaciones y asignándole a cada una de ellas su llave electrónica; tal como muestra el código siguiente, Hotel1.java : public class Hotel1 {
public static void main( String args[] ) {
Habitacion llaveHab1; // paso 1
Habitacion llaveHab2;
llaveHab1 = new Habitacion( 222 ); // pasos 2, 3, 4 y 5
llaveHab2 = new Habitacion( 1144,3 );
// ^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^
// A B y D C
}
}
Para explicar el proceso, dividimos las acciones en los cinco pasos necesarios para poder entrar en nuestra habitación. Aunque no se incluye, podemos también considerar el caso de que necesitemos un cerrajero, para que cuando perdamos la llave, nos abra la puerta; y que en nuestro caso sería el garbage collector , que recicla la habitación una vez que se hayan perdido todas las llaves.
El primer paso es la creación de la llave, es decir, definir la variable referencia, por defecto nula .
El resto de los pasos se agrupan en una sola sentencia Java. La parte B en el código anterior indica al gerente del Hotel que ya dispone de una nueva habitación. La parte C llama al decorador de interiores para que " vista " la habitación según un patrón determinado, para que no desentonen unas habitaciones con otras y no se pierdan las señas de identidad del hotel. El código electrónico que nos permitirá acceder a la habitación se genera en la parte D, una vez conocido el interior de la habitación y se programa en la llave en la parte A.
Si dejamos el ejemplo real a un lado y nos vamos a lo que ocurre en la ejecución del código, vemos que el operador new busca espacio para una instancia de un objeto de una clase determinada e inicializa la memoria a los valores adecuados. Luego invoca al método constructor de la clase, proporcionándole los argumentos adecuados. El operador new devuelve una referencia a sí mismo, que es inmediatamente asignada a la variable referencia.
Podemos tener múltiples llaves para una misma habitación: . . . Habitacion llaveHab3,llaveHab4; llaveHab3 = llaveHab1; llaveHab4 = llavehab2;
De este modo conseguimos copias de las llaves. Las habitaciones en sí mismas no se han tocado en este proceso. Así que, ya tenemos dos llaves para la habitación 222 y otras dos para la habitación 1144.
Una llave puede ser programada para que funcione solamente con una habitación en cualquier momento, pero podemos cambiar su código electrónico para que funcione con alguna otra habitación; por ejemplo, para cambiar una habitación anteriormente utilizada por un empedernido fumador por otra limpia de olores y con vistas al mar. Cambiemos pues la llave duplicada de la habitación del fumador (la 222) por la habitación con olor a sal marina, 1144: . . . llaveHab3 = llaveHab2;
Ahora tenemos una llave para la habitación 222 y tres para la habitación 1144. Mantendremos una llave para cada habitación en la conserjería, para poder utilizarla como llave maestra, en el caso de que alguien pierda su llave propia.
Alguien con la llave de una habitación puede hacer cambios en ella, y los compañeros que tengan llave de esa misma habitación, no tendrán conocimiento de esos cambios hasta que vuelvan a entrar en la habitación. Por ejemplo, vamos a quitar una de las camas de la habitación, entrando en ella con la llave maestra: . . . llaveHab2.camas( 2 );
Ahora cuando los inquilinos entren en la habitación podrán comprobar el cambio realizado: . . . llaveHab4.printData();

Paquetes de Java

2009-03-17T17:54:00.000-07:00

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).

Import

2009-03-15T17:53:00.001-07:00

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;

Import

2009-03-15T17:53:00.000-07:00

import java.Date;import java.awt.*;

import MiClase;

PAQUETES

2009-03-13T17:53:00.000-07:00

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

METODOS NATIVOS

2009-03-11T17:52:00.000-07:00

Java proporciona un mecanismo para la llamada a funciones C y C++ desde nuestro código fuente Java. Para definir métodos como funciones C o C++ se utiliza la palabra clave native .

public class Fecha

{
int ahora;
public Fecha() {
ahora = time();
}
private native int time();
static {
System.loadLibrary( "time" );
}
}

Una vez escrito el código Java, se necesitan ejecutar los pasos siguientes para poder integrar el código C o C++:
Utilizar javah para crear un fichero de cabecera (.h)
Utilizar javah para crear un fichero de stubs , es decir, que contiene la declaración de las funciones
Escribir el código del método nativo en C o C++, es decir, rellenar el código de la función, completando el trabajo de javah al crear el fichero de stubs
Compilar el fichero de stubs y el fichero .c en una librería de carga dinámica ( DLL en Windows '95 o libXX.so en Unix)

Ejecutar la aplicación con el appletviewer

Más adelante trataremos en profundidad los métodos nativos, porque añaden una gran potencia a Java, al permitirle integrar a través de librería dinámica cualquier algoritmo desarrollado en C o C++, lo cual, entre otras cosas, se utiliza como método de protección contra la descompilación completa del código Java.

Interfaces

2009-03-09T12:31:00.000-07:00

Los métodos abstractos son útiles cuando se quiere que cada implementación de la clase parezca y funcione igual, pero necesita que se cree una nueva clase para utilizar los métodos abstractos.
Los interfaces proporcionan un mecanismo para abstraer los métodos a un nivel superior.
Un interface contiene una colección de métodos que se implementan en otro lugar. Los métodos de una clase son public , static y final .

La principal diferencia entre interface y abstract es que un interface proporciona un mecanismo de encapsulación de los protocolos de los métodos sin forzar al usuario a utilizar la herencia.
Por ejemplo:

public interface VideoClip {
// comienza la reproduccion del video
void play();
// reproduce el clip en un bucle
void bucle();
// detiene la reproduccion
void stop();
}

Las clases que quieran utilizar el interface VideoClip utilizarán la palabra implements y proporcionarán el código necesario para implementar los métodos que se han definido para el interface:

class MiClase implements VideoClip {
void play() {

}
void bucle() {

}
void stop() {

}

Al utilizar implements para el interface es como si se hiciese una acción de copiar-y-pegar del código del interface, con lo cual no se hereda nada, solamente se pueden usar los métodos.
La ventaja principal del uso de interfaces es que una clase interface puede ser implementada por cualquier número de clases, permitiendo a cada clase compartir el interfaz de programación sin tener que ser consciente de la implementación que hagan las otras clases que implementen el interface .

class MiOtraClase implements VideoClip {
void play() {

}
void bucle() {

}
void stop() {

}

Clases Abstractas

2009-03-07T12:30:00.000-08:00

Una de las características más útiles de cualquier lenguaje orientado a objetos es la posibilidad de declarar clases que definen como se utiliza solamente, sin tener que implementar métodos. Esto es muy útil cuando la implementación es específica para cada usuario, pero todos los usuarios tienen que utilizar los mismos métodos. Un ejemplo de clase abstracta en Java es la clase Graphics : public abstract class Graphics {
public abstract void drawLine( int x1,int y1,int x2,
int y2 );
public abstract void drawOval( int x,int y,int width,
int height );
public abstract void drawArc( int x,int y,int width,
int height,int startAngle,int arcAngle );
. . .
}
Los métodos se declaran en la clase Graphics , pero el código que ejecutará el método está en algún otro sitio: public class MiClase extends Graphics {
public void drawLine( int x1,int y1,int x2,int y2 ) {
la arquitectura->
}
}
Cuando una clase contiene un método abstracto tiene que declararse abstracta. No obstante, no todos los métodos de una clase abstracta tienen que ser abstractos. Las clases abstractas no pueden tener métodos privados (no se podrían implementar) ni tampoco estáticos. Una clase abstracta tiene que derivarse obligatoriamente, no se puede hacer un new de una clase abstracta.
Una clase abstracta en Java es lo mismo que en C++ virtual func() = 0; lo que obliga a que al derivar de la clase haya que implementar forzosamente los métodos de esa clase abstracta.

this y super

2009-03-05T12:29:00.000-08:00

Al acceder a variables de instancia de una clase, la palabra clave this hace referencia a los miembros de la propia clase. Volviendo al ejemplo de MiClase, se puede añadir otro constructor de la forma siguiente: public class MiClase {
int i;
public MiClase() {
i = 10;
}
// Este constructor establece el valor de i
public MiClase( int valor ) {
this.i = valor; // i = valor
}
public void Suma_a_i( int j ) {
i = i + j;
}
}
Aquí this.i se refiere al entero i en la clase MiClase .
Si se necesita llamar al método padre dentro de una clase que ha reemplazado ese método, se puede hacer referencia al método padre con la palabra clave super : import MiClase;
public class MiNuevaClase extends MiClase {
public void Suma_a_i( int j ) {
i = i + ( j/2 );
super.Suma_a_i( j );
}
}
En el siguiente código, el constructor establecerá el valor de i a 10, después lo cambiará a 15 y finalmente el método Suma_a_i() de la clase padre (MiClase) lo dejará en 25: MiNuevaClase mnc; mnc = new MiNuevaClase(); mnc.Suma_a_i( 10 );

Variables y Métodos Estáticos

2009-03-03T12:26:00.000-08:00

En un momento determinado se puede querer crear una clase en la que el valor de una variable de instancia sea el mismo (y de hecho sea la misma variable) para todos los objetos instanciados a partir de esa clase. Es decir, que exista una única copia de la variable de instancia. Se usará para ello la palabra clave static . class Documento extends Pagina {
static int version = 10;
}
El valor de la variable version será el mismo para cualquier objeto instanciado de la clase Documento . Siempre que un objeto instanciado de Documento cambie la variable version , ésta cambiará para todos los objetos.
De la misma forma se puede declarar un método como estático, lo que evita que el método pueda acceder a las variables de instancia no estáticas: class Documento extends Pagina {
static int version = 10;
int numero_de_capitulos;
static void annade_un_capitulo() {
numero_de_capitulos++; // esto no funciona
}
static void modifica_version( int i ) {
version++; // esto si funciona
}
}
La modificación de la variable numero_de_capitulos no funciona porque se está violando una de las reglas de acceso al intentar acceder desde un método estático a una variable no estática.
Todas las clases que se derivan, cuando se declaran estáticas, comparten la misma página de variables; es decir, todos los objetos que se generen comparten la misma zona de memoria. Las funciones estáticas se usan para acceder solamente a variables estáticas. class UnaClase {
int var;
UnaClase()
{
var = 5;
}
UnaFuncion()
{
var += 5;
}
}
En el código anterior, si se llama a la función UnaFuncion a través de un puntero a función, no se podría acceder a var , porque al utilizar un puntero a función no se pasa implícitamente el puntero al propio objeto ( this ). Sin embargo, sí se podría acceder a var si fuese estática, porque siempre estaría en la misma posición de memoria para todos los objetos que se creasen de UnaClase.

CONTROL DE ACCESO

2009-03-01T11:59:00.000-08:00

Cuando se crea una nueva clase en Java, se puede especificar el nivel de acceso que se quiere para las variables de instancia y los métodos definidos en la clase:

public public void CualquieraPuedeAcceder(){}
Cualquier clase desde cualquier lugar puede acceder a las variables y métodos de instacia públicos.
protected protected void SoloSubClases(){}

Sólo las subclases de la clase y nadie más puede acceder a las variables y métodos de instancia protegidos.
private private String NumeroDelCarnetDeIdentidad;

Las variables y métodos de instancia privados sólo pueden ser accedidos desde dentro de la clase. No son accesibles desde las subclases.

friendly (sin declaración específica) void MetodoDeMiPaquete(){}

Por defecto, si no se especifica el control de acceso, las variables y métodos de instancia se declaran friendly (amigas), lo que significa que son accesibles por todos los objetos dentro del mismo paquete, pero no por los externos al paquete. Es lo mismo que protected.

Los métodos protegidos (protected) pueden ser vistos por las clases derivadas, como en C++, y también, en Java, por los paquetes (packages).

Todas las clases de un paquete pueden ver los métodos protegidos de ese paquete. Para evitarlo, se deben declarar como private protected , lo que hace que ya funcione como en C++ en donde sólo se puede acceder a las variables y métodos protegidos de las clases derivadas.

HERENCIA

2009-02-27T11:58:00.000-08:00

La Herencia es el mecanismo por el que se crean nuevos objetos definidos en términos de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se puede crear la subclase Pato, que es una especialización de Ave. class Pato extends Ave {
int numero_de_patas;
}

La palabra clave extends se usa para generar una subclase (especialización) de un objeto. Una Pato es una subclase de Ave. Cualquier cosa que contenga la definición de Ave será copiada a la clase Pato, además, en Pato se pueden definir sus propios métodos y variables de instancia. Se dice que Pato deriva o hereda de Ave.
Además, se pueden sustituir los métodos proporcionados por la clase base. Utilizando nuestro anterior ejemplo de MiClase, aquí hay un ejemplo de una clase derivada sustituyendo a la función Suma_a_i() : import MiClase;
public class MiNuevaClase extends MiClase {
public void Suma_a_i( int j ) {
i = i + ( j/2 );
}
}

Ahora cuando se crea una instancia de MiNuevaClase, el valor de i también se inicializa a 10, pero la llamada al método Suma_a_i() produce un resultado diferente: MiNuevaClase mnc;
mnc = new MiNuevaClase();
mnc.Suma_a_i( 10 );

En Java no se puede hacer herencia múltiple. Por ejemplo, de la clase aparato con motor y de la clase animal no se puede derivar nada, sería como obtener el objeto toro mecánico a partir de una máquina motorizada (aparato con motor) y un toro (aminal).

En realidad, lo que se pretende es copiar los métodos, es decir, pasar la funcionalidad del toro de verdad al toro mecánico, con lo cual no sería necesaria la herencia múltiple sino simplemente la compartición de funcionalidad que se encuentra implementada en Java a través de interfaces .

ALCANCE DE OBJETOS Y RECICLADO DE MEMORIA

2009-02-25T11:58:00.000-08:00

Los objetos tienen un tiempo de vida y consumen recursos durante el mismo. Cuando un objeto no se va a utilizar más, debería liberar el espacio que ocupaba en la memoria de forma que las aplicaciones no la agoten (especialmente las grandes).

En Java, la recolección y liberación de memoria es responsabilidad de un thread llamado automatic garbage collector (recolector automático de basura). Este thread monitoriza el alcance de los objetos y marca los objetos que se han salido de alcance. Veamos un ejemplo: String s; // no se ha asignado todavia
s = new String( "abc" ); // memoria asignada
s = "def"; // se ha asignado nueva memoria
// (nuevo objeto)

Más adelante veremos en detalle la clase String , pero una breve descripción de lo que hace esto es; crear un objeto String y rellenarlo con los caracteres "abc" y crear otro (nuevo) String y colocarle los caracteres "def".
En esencia se crean dos objetos: Objeto String "abc"
Objeto String "def"

Al final de la tercera sentencia, el primer objeto creado de nombre s que contiene "abc" se ha salido de alcance. No hay forma de acceder a él. Ahora se tiene un nuevo objeto llamado s y contiene "def". Es marcado y eliminado en la siguiente iteración del thread reciclador de memoria.

Finalizadores

2009-02-23T11:57:00.000-08:00

Java no utiliza destructores (al contrario que C++) ya que tiene una forma de recoger automáticamente todos los objetos que se salen del alcance.

No obstante proporciona un método que, cuando se especifique en el código de la clase, el reciclador de memoria (garbage collector) llamará:

// Cierra el canal cuando este objeto es reciclado

protected void finalize() {
close();
}

Métodos y Constructores

2009-02-21T11:57:00.000-08:00

Los métodos son funciones que pueden ser llamadas dentro de la clase o por otras clases. El constructor es un tipo específico de método que siempre tiene el mismo nombre que la clase.

Cuando se declara una clase en Java, se pueden declarar uno o más constructores opcionales que realizan la inicialización cuando se instancia (se crea una ocurrencia) un objeto de dicha clase.

Utilizando el código de ejemplo anterior, cuando se crea una nueva instancia de MiClase, se crean (instancian) todos los métodos y variables, y se llama al constructor de la clase: MiClase mc;

mc = new MiClase();
La palabra clave new se usa para crear una instancia de la clase. Antes de ser instanciada con new no consume memoria, simplemente es una declaración de tipo. Después de ser instanciado un nuevo objeto mc, el valor de i en el objeto mc será igual a 10. Se puede referenciar la variable (de instancia) i con el nombre del objeto: mc.i++; // incrementa la instancia de i de mc

Al tener mc todas las variables y métodos de MiClase, se puede usar la primera sintaxis para llamar al método Suma_a_i() utilizando el nuevo nombre de clase mc: mc.Suma_a_i( 10 );
y ahora la variable mc.i vale 21.

Ambito de una variable

2009-02-19T11:56:00.000-08:00

Los bloques de sentencias compuestas en Java se delimitan con dos llaves. Las variables de Java sólo son válidas desde el punto donde están declaradas hasta el final de la sentencia compuesta que la engloba. Se pueden anidar estas sentencias compuestas, y cada una puede contener su propio conjunto de declaraciones de variables locales.

Sin embargo, no se puede declarar una variable con el mismo nombre que una de ámbito exterior.

El siguiente ejemplo intenta declarar dos variables separadas con el mismo nombre. En C y C++ son distintas, porque están declaradas dentro de ámbitos diferentes. En Java, esto es ilegal.Class Ambito {
int i = 1; // ámbito exterior
{ // crea un nuevo ámbito
int i = 2; // error de compilación
}
}

VARIABLES Y METODOS DE INSTANCIA

2009-02-17T11:56:00.000-08:00

Una clase en Java puede contener variables y métodos. Las variables pueden ser tipos primitivos como int, char, etc. Los métodos son funciones.
Por ejemplo, en el siguiente trozo de código podemos observarlo: public MiClase {
int i;
public MiClase() {
i = 10;
}
public void Suma_a_i( int j ) {
i = i + j;
}
}
La clase MiClase contiene una variable (i) y dos métodos, MiClase que es el constructor de la clase y Suma_a_i( int j ).

Tipos de Clases

2009-02-15T11:55:00.000-08:00

Hasta ahora sólo se ha utilizado la palabra clave public para calificar el nombre de las clases que hemos visto, pero hay tres modificadores más. Los tipos de clases que podemos definir son:
abstract
Una clase abstract tiene al menos un método abstracto. Una clase abstracta no se instancia, sino que se utiliza como clase base para la herencia.
final
Una clase final se declara como la clase que termina una cadena de herencia. No se puede heredar de una clase final. Por ejemplo, la clase Math es una clase final.
public
Las clases public son accesibles desde otras clases, bien sea directamente o por herencia. Son accesibles dentro del mismo paquete en el que se han declarado. Para acceder desde otros paquetes, primero tienen que ser importadas.
synchronizable
Este modificador especifica que todos los métodos definidos en la clase son sincronizados, es decir, que no se puede acceder al mismo tiempo a ellos desde distintos threads; el sistema se encarga de colocar los flags necesarios para evitarlo. Este mecanismo hace que desde threads diferentes se puedan modificar las mismas variables sin que haya problemas de que se sobreescriban.

CLASES

2009-02-13T11:55:00.000-08:00

Las clases son lo más simple de Java. Todo en Java forma parte de una clase, es una clase o describe como funciona una clase. El conocimiento de las clases es fundamental para poder entender los programas Java.
Todas las acciones de los programas Java se colocan dentro del bloque de una clase o un objeto. Todos los métodos se definen dentro del bloque de la clase, Java no soporta funciones o variables globales. Esto puede despistar a los programadores de C++, que pueden definir métodos fuera del bloque de la clase, pero esta posibilidad es más un intento de no separarse mucho y ser compatible con C, que un buen diseño orientado a objetos. Así pues, el esqueleto de cualquier aplicación Java se basa en la definición de una clase.
Todos los datos básicos, como los enteros, se deben declarar en las clases antes de hacer uso de ellos. En C la unidad fundamental son los ficheros con código fuente, en Java son las clases. De hecho son pocas las sentencias que se pueden colocar fuera del bloque de una clase. La palabra clave import (equivalente al #include) puede colocarse al principio de un fichero, fuera del bloque de la clase. Sin embargo, el compilador reemplazará esa sentencia con el contenido del fichero que se indique, que consistirá, como es de suponer, en más clases.

Métodos Nativos

2009-02-11T12:32:00.000-08:00

Java proporciona un mecanismo para la llamada a funciones C y C++ desde nuestro código fuente Java. Para definir métodos como funciones C o C++ se utiliza la palabra clave native .

public class Fecha {
int ahora;
public Fecha() {
ahora = time();
}
private native int time();
static {
System.loadLibrary( "time" );
}
}

Compilar el fichero de stubs y el fichero .c en una librería de carga dinámica ( DLL en Windows '95 o libXX.so en Unix)

Ejecutar la aplicación con el appletviewer

Control General del Flujo

2009-02-11T11:54:00.000-08:00

break

continue [etiqueta]
return expr;
etiqueta: sentencia;
En caso de que nos encontremos con bucles anidados, se permite el uso de etiquetas para poder salirse de ellos, por ejemplo: uno: for( )
{
dos: for( )
{
continue; // seguiría en el bucle interno
continue uno; // seguiría en el bucle principal
break uno; // se saldría del bucle principal
}
}
En el código de una función siempre hay que ser consecuentes con la declaración que se haya hecho de ella. Por ejemplo, si se declara una función para que devuelva un entero, es imprescindible que se coloque un return final para salir de esa función, independientemente de que haya otros en medio del código que también provoquen la salida de la función. En caso de no hacerlo se generará un Warning, y el código Java no se puede compilar con Warnings. int func()
{
if( a == 0 )
return 1;
return 0; // es imprescindible porque se retorna un entero
}

CONTROL DE FLUJO

2009-02-09T11:54:00.000-08:00

Muchas de las sentencias de control del flujo del programa se han tomado del C:
Sentencias de Salto
if/else if( Boolean ) {
sentencias;
}
else {
sentencias;
}
switch switch( expr1 ) {
case expr2:
sentencias;
break;
case expr3:
sentencias;
break;
default:
sentencias;
break;
}
Sentencias de Bucle
Bucles for for( expr1 inicio; expr2 test; expr3 incremento ) {
sentencias;
}
El siguiente trocito de código Java que dibuja varias líneas en pantalla alternando sus colores entre rojo, azul y verde. Este fragmento sería parte de una función Java (método): int contador;
for( contador=1; contador <= 12; contador++ ) {
switch( contador % 3 ) {
case 0:
setColor( Color.red );
break;
case 1:
setColor( Color.blue );
break;
case 2:
setColor( Color.green );
break;
}
g.drawLine( 10,contador*10,80,contador*10 );
}
También se soporta el operador coma (,) en los bucles for for( a=0,b=0; a < 7; a++,b+=2 )
Bucles while while( Boolean ) {
sentencias;
}
Bucles do/while do {
sentencias;
}while( Boolean );
Excepciones
try-catch-throw try {
sentencias;
} catch( Exception ) {
sentencias;
}
Java implementa excepciones para facilitar la construcción de código robusto. Cuando ocurre un error en un programa, el código que encuentra el error lanza una excepción, que se puede capturar y recuperarse de ella. Java proporciona muchas excepciones predefinidas.

Identificadores

2009-02-07T14:58:00.000-08:00

Los identificadores nombran variables, funciones, clases y objetos; cualquier cosa que el programador necesite identificar o usar. En Java, un identificador comienza con una letra, un subrayado (_) o un símbolo de dólar ($). Los siguientes caracteres pueden ser letras o dígitos. Se distinguen las mayúsculas de las minúsculas y no hay longitud máxima. Serían identificadores válidos: identificador nombre_usuario Nombre_Usuario _variable_del_sistema $transaccion y su uso sería, por ejemplo: int contador_principal; char _lista_de_ficheros; float $cantidad_en_Ptas;

Palabras clave

2009-02-05T14:59:00.000-08:00

Las siguientes son las palabras clave que están definidas en Java y que no se pueden utilizar como indentificadores: abstract continue for new switch boolean default goto null synchronized break do if package this byte double implements private threadsafe byvalue else import protected throw case extends instanceof public transient catch false int return true char final interface short try class finally long static void const float native super while Palabras ReservadasAdemás, el lenguaje se reserva unas cuantas palabras más, pero que hasta ahora no tienen un cometido específico. Son: cast future generic inner operator outer rest var LiteralesUn valor constante en Java se crea utilizando una representación literal de él. Java utiliza cinco tipos de elementos: enteros, reales en coma flotante, booleanos, caracteres y cadenas, que se pueden poner en cualquier lugar del código fuente de Java. Cada uno de estos literales tiene un tipo correspondiente asociado con él. Enteros: byte 8 bits complemento a dos short 16 bits complemento a dos int 32 bits complemento a dos long 64 bits complemento a dos Por ejemplo: 21 077 0xDC00 Reales en coma flotante: float 32 bits IEEE 754 double 64 bits IEEE 754 Por ejemplo: 3.14 2e12 3.1E12 Booleanos: true false Caracteres: Por ejemplo: a t u???? [????] es un número unicode Cadenas: Por ejemplo: "Esto es una cadena literal" ArraysSe pueden declarar en Java arrays de cualquier tipo: char s[]; int iArray[]; Incluso se pueden construir arrays de arrays: int tabla[][] = new int[4][5]; Los límites de los arrays se comprueban en tiempo de ejecución para evitar desbordamientos y la corrupción de memoria. En Java un array es realmente un objeto, porque tiene redefinido el operador []. Tiene una función miembro: length. Se puede utilizar este método para conocer la longitud de cualquier array. int a[][] = new int[10][3]; a.length; /* 10 */ a[0].length; /* 3 */ Para crear un array en Java hay dos métodos básicos. Crear un array vacío: int lista[] = new int[50]; o se puede crear ya el array con sus valores iniciales: String nombres[] = { "Juan","Pepe","Pedro","Maria" }; Esto que es equivalente a: String nombres[]; nombres = new String[4]; nombres[0] = new String( "Juan" ); nombres[1] = new String( "Pepe" ); nombres[2] = new String( "Pedro" ); nombres[3] = new String( "Maria" ); No se pueden crear arrays estáticos en tiempo de compilación: int lista[50]; // generará un error en tiempo de compilación Tampoco se puede rellenar un array sin declarar el tamaño con el operador new: int lista[]; for( int i=0; i <>

Separadores

2009-02-03T14:58:00.000-08:00

Sólo hay un par de secuencias con otros caracteres que pueden aparecer en el código Java; son los separadores simples, que van a definir la forma y función del código. Los separadores admitidos en Java son:
() - paréntesis. Para contener listas de parámetros en la definición y llamada a métodos. También se utiliza para definir precedencia en expresiones, contener expresiones para control de flujo y rodear las conversiones de tipo.
{} - llaves. Para contener los valores de matrices inicializadas automáticamente. También se utiliza para definir un bloque de código, para clases, métodos y ámbitos locales.
[] - corchetes. Para declarar tipos matriz. También se utiliza cuando se referencian valores de matriz.
; - punto y coma. Separa sentencias.
, - coma. Separa identificadores consecutivos en una declaración de variables. También se utiliza para encadenar sentencias dentro de una sentencia for.
. - punto. Para separar nombres de paquete de subpaquetes y clases. También se utiliza para separar una variable o método de una variable de referencia.

Operadores

2009-02-01T14:57:00.000-08:00

Los operadores de Java son muy parecidos en estilo y funcionamiento a los de C. En la siguiente tabla aparecen los operadores que se utilizan en Java, por orden de precedencia: . [] () ++ -- ! ~ instanceof * / % + - << >> >>> < > <= >= == != & ^ && ? : = op= (*= /= %= += -= etc.) ,
Los operadores numéricos se comportan como esperamos: int + int = int
Los operadores relacionales devuelven un valor booleano.
Para las cadenas, se pueden utilizar los operadores relacionales para comparaciones además de + y += para la concatenación: String nombre = "nombre" + "Apellido";
El operador = siempre hace copias de objetos, marcando los antiguos para borrarlos, y ya se encargará el garbage collector de devolver al sistema la memoria ocupada por el objeto eliminado.

Programación

2009-01-31T14:56:00.000-08:00

Cuando se programa en Java, se coloca todo el código en métodos, de la misma forma que se escriben funciones en lenguajes como C.

Comentarios

En Java hay tres tipos de comentarios: // comentarios para una sola línea/* comentarios de una o más líneas *//** comentario de documentación, de una o más líneas */
Los dos primeros tipos de comentarios son los que todo programador conoce y se utilizan del mismo modo. Los comentarios de documentación, colocados inmediatamente antes de una declaración (de variable o función), indican que ese comentario ha de ser colocado en la documentación que se genera automáticamente cuando se utiliza la herramienta de Java, javadoc. Dichos comentarios sirven como descripción del elemento declarado permitiendo generar una documentación de nuestras clases escrita al mismo tiempo que se genera el código.
En este tipo de comentario para documentación, se permite la introducción de algunos tokens o palabras clave, que harán que la información que les sigue aparezca de forma diferente al resto en la documentación.

Café Saludable

2009-01-18T12:38:00.000-08:00

Acabo de descrubrir algo importante para la salud y lo comparto contigo se trata del llamado "cafecito milagroso". A continuación una pequeña explicación y la página de internet muy interesante:

En una breve descripción el Lingzhi es un hongo usado desde hace mas de 2000 años por la medicina oriental y considerado como la hierba curativa por excelencia, su efecto no consiste en atacar alguna enfermedad especifica, nuestro cuerpo es una maquina extraordinaria y el es capaz de deshacerse por si mismo de cualquier enfermedad, pero a veces necesita un poco de ayuda, esa es la ayuda que proporciona el Ganoderma Lucidum, al consumirlo usted notara como su organismo comenzara a deshacerse por si mismo de todas las sustancias dañinas que antes no podía desechar y terminaban en forma de grasa en las arterias y obesidad, toxinas por todo nuestro cuerpo.

La pagina es:

www.cafesaludable.tk

Conceptos Basicos

2009-01-15T19:26:00.001-08:00

Ahora que ya hemos visto a grandes rasgos lo que Java puede ofrecernos, y antes de entrar a saco en la generación de nuestro primer código Java, vamos a echar un vistazo al lenguaje Java en sí. Lo básico resultará muy familiar a los que tengan conocimientos de C/C++.

Los programadores con experiencia en otros lenguajes procedurales reconocerán la mayor parte de las construcciones. Esperemos que este capítulo no resulte demasiado intenso, no obstante, sí debe estar presente, porque más de una vez recurriremos a él como referencia.

En posteriores capítulos profundizaremos sobre aspectos de la programación en Java por los que aquí pasaremos de puntillas e iremos presentando ejemplos de código de cada uno de esos aspectos de la programación en Java.

Instalación del JSDK

2009-01-15T19:23:00.000-08:00

El SDK de Java (JSDK) se proporciona gratuitamente desde la web de SUN. Para los ejemplos que aparecen en este manual la versión más idónea es J2SE (Java 2 Standardad Edition). Es la distribución base que cualquier kit de Java necesitará. Se puede obtener desde aquí http://java.sun.com/j2se/1.4.2/download.html

Además, en esa misma dirección podremos descargar el NetBeans, un potente editor de Java que nos facilitará la tarea de programar, compilar y resolver errores entre otras muchas cosas. Java es actualmente uno de los lenguajes más populares y existen multitud de editores para él. Los más conocidos son el JDeveloper, JBuilder, Visual J++ y por supuesto el propio NetBeans, de SUN.

Sin embargo, aquí trataremos solo el uso del SDK, sin editor, ya que es lo más recomendable. Si sabemos utilizar el SDK sin herramientas adicionales, tendremos mayor facilidad para usar cualquier editor y siempre que estemos faltos de algún editor, podremos salir del paso sin él.

Las herramientas que trae el SDK y que más utilizaremos son:

java (ejecutable): Ejecuta cualquier programa compilado de Java

javac (compilador): Compilará el código fuente escrito en Java.

Java no se ofrece de forma gratuita. No todas las máquinas disponen de la versión del Java Development Kit para ejecutarse en ellas. Por ello, solamente comentaré la instalación de JDK en Solaris, Windows y Linux.
Actualmente ya hay entornos de desarrollo integrados completos para Java, diferentes del JDK de Sun. Oracle dispone de un entorno de desarrollo de Java, la propia SUN ofrece el entorno NetBeans y Borland posee el JBuilder. Además Microsoft ofrece soporte Java en su plataforma .NET.

No obstante, trataremos solamente el JDK. El entorno básico del JDK de Java que proporciona Sun está formado por herramientas en modo texto, que son: java, intérprete que ejecuta programas en byte-code. javac, compilador de Java que convierte el código fuente en byte-code. javah, crea ficheros de cabecera para implementar métodos para cualquier clase. javap, es un descompilador de byte-code a código fuente Java. javadoc, es un generador automático de documentos HTML a partir del código fuente Java. javaprof, es un profiler para aplicaciones de un solo thread.

El entorno habitual pues, consiste en un navegador que pueda ejecutar applets, un compilador que convierta el código fuente Java a byte-code y el intérprete Java para ejecutar los programas. Estos son los componenetes básicos para desarrollar algo en Java. No obstante se necesita un editor para escribir el código fuente, y no son estrictamente necesarias otras herramientas como el debugger, un entorno visual, la documentación o un visualizador de jerarquía de clases. Cualquier navegador actual servirá para mostrar los Applets Java que realicemos.
La instalación en un principio es como la de cualquier otro programa, pero una vez lo hayamos instalado tenemos que incluir en el path del sistema operativo la ruta hacia el directorio bin. Por ejemplo si hemos instalado Java en:

c:java

En el PATH de nuestro sistema operativo debe estar presente la ruta:

c:javabin

En Windows XP, para cambiar las variables del sistema, se debe ir a Inicio > Configuración > Panel de Control > Sistema > Opciones Avanzadas > Variables de entorno.

Una vez hecho esto, abrimos la consola, Inicio > Ejecutar > cmd y ya deberían estar disponibles los comandos "java" y "javac".

En Linux la instalación es muy similar.

Características de Java

2008-12-31T15:40:00.000-08:00

Las características principales que nos ofrece Java respecto a cualquier otro lenguaje de programación, son:
Es SIMPLE :
Java ofrece toda la funcionalidad de un lenguaje potente, pero sin las características menos usadas y más confusas de éstos. C++ es un lenguaje que adolece de falta de seguridad, pero C y C++ son lenguajes más difundidos, por ello Java se diseñó para ser parecido a C++ y así facilitar un rápido y fácil aprendizaje.
Java elimina muchas de las características de otros lenguajes como C++, para mantener reducidas las especificaciones del lenguaje y añadir características muy útiles como el garbage collector (reciclador de memoria dinámica). No es necesario preocuparse de liberar memoria, el reciclador se encarga de ello y como es un thread de baja prioridad, cuando entra en acción, permite liberar bloques de memoria muy grandes, lo que reduce la fragmentación de la memoria.
Java reduce en un 50% los errores más comunes de programación con lenguajes como C y C++ al eliminar muchas de las características de éstos, entre las que destacan:
aritmética de punteros
no existen referencias
registros (struct)
definición de tipos (typedef)
macros (#define)
necesidad de liberar memoria (free)
Aunque, en realidad, lo que hace es eliminar las palabras reservadas (struct, typedef), ya que las clases son algo parecido.
Además, el intérprete completo de Java que hay en este momento es muy pequeño, solamente ocupa 215 Kb de RAM.

Es ORIENTADO A OBJETOS :
Java implementa la tecnología básica de C++ con algunas mejoras y elimina algunas cosas para mantener el objetivo de la simplicidad del lenguaje. Java trabaja con sus datos como objetos y con interfaces a esos objetos. Soporta las tres características propias del paradigma de la orientación a objetos: encapsulación, herencia y polimorfismo. Las plantillas de objetos son llamadas, como en C++, clases y sus copias, instancias . Estas instancias, como en C++, necesitan ser construidas y destruidas en espacios de memoria.
Java incorpora funcionalidades inexistentes en C++ como por ejemplo, la resolución dinámica de métodos. Esta característica deriva del lenguaje Objective C, propietario del sistema operativo Next. En C++ se suele trabajar con librerías dinámicas (DLLs) que obligan a recompilar la aplicación cuando se retocan las funciones que se encuentran en su interior. Este inconveniente es resuelto por Java mediante una interfaz específica llamada RTTI ( RunTime Type Identification ) que define la interacción entre objetos excluyendo variables de instancias o implementación de métodos. Las clases en Java tienen una representación en el runtime que permite a los programadores interrogar por el tipo de clase y enlazar dinámicamente la clase con el resultado de la búsqueda.
Es DISTRIBUIDO :
Java se ha construido con extensas capacidades de interconexión TCP/IP. Existen librerías de rutinas para acceder e interactuar con protocolos como http y ftp . Esto permite a los programadores acceder a la información a través de la red con tanta facilidad como a los ficheros locales.
La verdad es que Java en sí no es distribuido, sino que proporciona las librerías y herramientas para que los programas puedan ser distribuidos, es decir, que se corran en varias máquinas, interactuando.
Es ROBUSTO :
Java realiza verificaciones en busca de problemas tanto en tiempo de compilación como en tiempo de ejecución. La comprobación de tipos en Java ayuda a detectar errores, lo antes posible, en el ciclo de desarrollo. Java obliga a la declaración explícita de métodos, reduciendo así las posibilidades de error. Maneja la memoria para eliminar las preocupaciones por parte del programador de la liberación o corrupción de memoria. También implementa los arrays auténticos , en vez de listas enlazadas de punteros, con comprobación de límites, para evitar la posibilidad de sobreescribir o corromper memoria resultado de punteros que señalan a zonas equivocadas. Estas características reducen drásticamente el tiempo de desarrollo de aplicaciones en Java.
Además, para asegurar el funcionamiento de la aplicación, realiza una verificación de los byte-codes , que son el resultado de la compilación de un programa Java. Es un código de máquina virtual que es interpretado por el intérprete Java. No es el código máquina directamente entendible por el hardware, pero ya ha pasado todas las fases del compilador: análisis de instrucciones, orden de operadores, etc., y ya tiene generada la pila de ejecución de órdenes.
Java proporciona, pues:
Comprobación de punteros
Comprobación de límites de arrays
Excepciones
Verificación de byte-codes
Es de ARQUITECTURA NEUTRAL :
Para establecer Java como parte integral de la red, el compilador Java compila su código a un fichero objeto de formato independiente de la arquitectura de la máquina en que se ejecutará. Cualquier máquina que tenga el sistema de ejecución ( run-time ) puede ejecutar ese código objeto, sin importar en modo alguno la máquina en que ha sido generado. Actualmente existen sistemas run-time para Solaris 2.x, SunOs 4.1.x, Windows 95, Windows NT, Linux, Irix, Aix, Mac, Apple y probablemente haya grupos de desarrollo trabajando en el porting a otras plataformas.

El código fuente Java se "compila" a un código de bytes de alto nivel independiente de la máquina. Este código (byte-codes) está diseñado para ejecutarse en una máquina hipotética que es implementada por un sistema run-time, que sí es dependiente de la máquina.
En una representación en que tuviésemos que indicar todos los elementos que forman parte de la arquitectura de Java sobre una plataforma genérica.

En ella podemos ver que lo verdaderamente dependiente del sistema es la Máquina Virtual Java (JVM) y las librerías fundamentales, que también nos permitirían acceder directamente al hardware de la máquina. Además, habrá APIs de Java que también entren en contacto directo con el hardware y serán dependientes de la máquina, como ejemplo de este tipo de APIs podemos citar:
Java 2D: gráficos 2D y manipulación de imágenes
Java Media Framework : Elementos críticos en el tiempo: audio, video...
Java Animation: Animación de objetos en 2D
Java Telephony: Integración con telefonía
Java Share: Interacción entre aplicaciones multiusuario
Java 3D: Gráficos 3D y su manipulación
Es SEGURO :
La seguridad en Java tiene dos facetas. En el lenguaje, características como los punteros o el casting implícito que hacen los compiladores de C y C++ se eliminan para prevenir el acceso ilegal a la memoria. Cuando se usa Java para crear un navegador, se combinan las características del lenguaje con protecciones de sentido común aplicadas al propio navegador.
El lenguaje C, por ejemplo, tiene lagunas de seguridad importantes, como son los errores de alineación . Los programadores de C utilizan punteros en conjunción con operaciones aritméticas. Esto le permite al programador que un puntero referencie a un lugar conocido de la memoria y pueda sumar (o restar) algún valor, para referirse a otro lugar de la memoria. Si otros programadores conocen nuestras estructuras de datos pueden extraer información confidencial de nuestro sistema. Con un lenguaje como C, se pueden tomar números enteros aleatorios y convertirlos en punteros para luego acceder a la memoria: printf( "Escribe un valor entero: " );
scanf( "%u",&puntero );
printf( "Cadena de memoria: %sn",puntero );
Otra laguna de seguridad u otro tipo de ataque, es el Caballo de Troya . Se presenta un programa como una utilidad, resultando tener una funcionalidad destructiva. Por ejemplo, en UNIX se visualiza el contenido de un directorio con el comando ls . Si un programador deja un comando destructivo bajo esta referencia, se puede correr el riesgo de ejecutar código malicioso, aunque el comando siga haciendo la funcionalidad que se le supone, después de lanzar su carga destructiva. Por ejemplo, después de que el caballo de Troya haya enviado por correo el /etc/shadow a su creador, ejecuta la funcionalidad de ls persentando el contenido del directorio. Se notará un retardo, pero nada inusual.
El código Java pasa muchos tests antes de ejecutarse en una máquina. El código se pasa a través de un verificador de byte-codes que comprueba el formato de los fragmentos de código y aplica un probador de teoremas para detectar fragmentos de código ilegal -código que falsea punteros, viola derechos de acceso sobre objetos o intenta cambiar el tipo o clase de un objeto-.
Si los byte-codes pasan la verificación sin generar ningún mensaje de error, entonces sabemos que:
El código no produce desbordamiento de operandos en la pila
El tipo de los parámetros de todos los códigos de operación son conocidos y correctos
No ha ocurrido ninguna conversión ilegal de datos, tal como convertir enteros en punteros
El acceso a los campos de un objeto se sabe que es legal: public, private, protected
No hay ningún intento de violar las reglas de acceso y seguridad establecidas
El Cargador de Clases también ayuda a Java a mantener su seguridad, separando el espacio de nombres del sistema de ficheros local, del de los recursos procedentes de la red. Esto limita cualquier aplicación del tipo Caballo de Troya , ya que las clases se buscan primero entre las locales y luego entre las procedentes del exterior.
Las clases importadas de la red se almacenan en un espacio de nombres privado, asociado con el origen. Cuando una clase del espacio de nombres privado accede a otra clase, primero se busca en las clases predefinidas (del sistema local) y luego en el espacio de nombres de la clase que hace la referencia. Esto imposibilita que una clase suplante a una predefinida.
En resumen, las aplicaciones de Java resultan extremadamente seguras, ya que no acceden a zonas delicadas de memoria o de sistema, con lo cual evitan la interacción de ciertos virus. Java no posee una semántica específica para modificar la pila de programa, la memoria libre o utilizar objetos y métodos de un programa sin los privilegios del kernel del sistema operativo. Además, para evitar modificaciones por parte de los crackers de la red, implementa un método ultraseguro de autentificación por clave pública. El Cargador de Clases puede verificar una firma digital antes de realizar una instancia de un objeto. Por tanto, ningún objeto se crea y almacena en memoria, sin que se validen los privilegios de acceso. Es decir, la seguridad se integra en el momento de compilación, con el nivel de detalle y de privilegio que sea necesario.
Dada, pues la concepción del lenguaje y si todos los elementos se mantienen dentro del estándar marcado por Sun, no hay peligro. Java imposibilita, también, abrir ningún fichero de la máquina local (siempre que se realizan operaciones con archivos, éstas trabajan sobre el disco duro de la máquina de donde partió el applet), no permite ejecutar ninguna aplicación nativa de una plataforma e impide que se utilicen otros ordenadores como puente, es decir, nadie puede utilizar nuestra máquina para hacer peticiones o realizar operaciones con otra. Además, los intérpretes que incorporan los navegadores de la Web son aún más restrictivos. Bajo estas condiciones (y dentro de la filosofía de que el único ordenador seguro es el que está apagado, desenchufado, dentro de una cámara acorazada en un bunker y rodeado por mil soldados de los cuerpos especiales del ejército), se puede considerar que Java es un lenguaje seguro y que los applets están libres de virus.
Respecto a la seguridad del código fuente, no ya del lenguaje, JDK proporciona un desemsamblador de byte-code, que permite que cualquier programa pueda ser convertido a código fuente, lo que para el programador significa una vulnerabilidad total a su código. Utilizando javap no se obtiene el código fuente original, pero sí desmonta el programa mostrando el algoritmo que se utiliza, que es lo realmente interesante. La protección de los programadores ante esto es utilizar llamadas a programas nativos, externos (incluso en C o C++) de forma que no sea descompilable todo el código; aunque así se pierda portabilidad. Esta es otra de las cuestiones que Java tiene pendientes.
Es PORTABLE :
Más allá de la portabilidad básica por ser de arquitectura independiente, Java implementa otros estándares de portabilidad para facilitar el desarrollo. Los enteros son siempre enteros y además, enteros de 32 bits en complemento a 2. Además, Java construye sus interfaces de usuario a través de un sistema abstracto de ventanas de forma que las ventanas puedan ser implantadas en entornos Unix, Pc o Mac.
Es INTERPRETADO :
El intérprete Java (sistema run-time) puede ejecutar directamente el código objeto. Enlazar (linkar) un programa, normalmente, consume menos recursos que compilarlo, por lo que los desarrolladores con Java pasarán más tiempo desarrollando y menos esperando por el ordenador. No obstante, el compilador actual del JDK es bastante lento. Por ahora, que todavía no hay compiladores específicos de Java para las diversas plataformas, Java es más lento que otros lenguajes de programación, como C++, ya que debe ser interpretado y no ejecutado como sucede en cualquier programa tradicional.
Se dice que Java es de 10 a 30 veces más lento que C, y que tampoco existen en Java proyectos de gran envergadura como en otros lenguajes. La verdad es que ya hay comparaciones ventajosas entre Java y el resto de los lenguajes de programación, y una ingente cantidad de folletos electrónicos que supuran fanatismo en favor y en contra de los distintos lenguajes contendientes con Java. Lo que se suele dejar de lado en todo esto, es que primero habría que decidir hasta que punto Java, un lenguaje en pleno desarrollo y todavía sin definición definitiva, está maduro como lenguaje de programación para ser comparado con otros; como por ejemplo con Smalltalk, que lleva más de 20 años en cancha.
La verdad es que Java para conseguir ser un lenguaje independiente del sistema operativo y del procesador que incorpore la máquina utilizada, es tanto interpretado como compilado. Y esto no es ningún contrasentido, me explico, el código fuente escrito con cualquier editor se compila generando el byte-code. Este código intermedio es de muy bajo nivel, pero sin alcanzar las instrucciones máquina propias de cada plataforma y no tiene nada que ver con el p-code de Visual Basic. El byte-code corresponde al 80% de las instrucciones de la aplicación. Ese mismo código es el que se puede ejecutar sobre cualquier plataforma. Para ello hace falta el run-time, que sí es completamente dependiente de la máquina y del sistema operativo, que interpreta dinámicamente el byte-code y añade el 20% de instrucciones que faltaban para su ejecución. Con este sistema es fácil crear aplicaciones multiplataforma, pero para ejecutarlas es necesario que exista el run-time correspondiente al sistema operativo utilizado.
Es MULTITHREADED :
Al ser multithreaded (multihilvanado, en mala traducción), Java permite muchas actividades simultáneas en un programa. Los threads (a veces llamados, procesos ligeros), son básicamente pequeños procesos o piezas independientes de un gran proceso. Al estar los threads contruidos en el lenguaje, son más fáciles de usar y más robustos que sus homólogos en C o C++.
El beneficio de ser miltithreaded consiste en un mejor rendimiento interactivo y mejor comportamiento en tiempo real. Aunque el comportamiento en tiempo real está limitado a las capacidades del sistema operativo subyacente (Unix, Windows, etc.), aún supera a los entornos de flujo único de programa (single-threaded) tanto en facilidad de desarrollo como en rendimiento.
Cualquiera que haya utilizado la tecnología de navegación concurrente, sabe lo frustrante que puede ser esperar por una gran imagen que se está trayendo. En Java, las imágenes se pueden ir trayendo en un thread independiente, permitiendo que el usuario pueda acceder a la información en la página sin tener que esperar por el navegador.
Es DINAMICO :
Java se beneficia todo lo posible de la tecnología orientada a objetos. Java no intenta conectar todos los módulos que comprenden una aplicación hasta el tiempo de ejecución. Las librería nuevas o actualizadas no paralizarán las aplicaciones actuales (siempre que mantengan el API anterior).

Java también simplifica el uso de protocolos nuevos o actualizados. Si su sistema ejecuta una aplicación Java sobre la red y encuentra una pieza de la aplicación que no sabe manejar, tal como se ha explicado en párrafos anteriores, Java es capaz de traer automáticamente cualquiera de esas piezas que el sistema necesita para funcionar.

Muestras Gratis

2008-12-11T10:57:00.000-08:00

Hola,
Acabo de encontrar un nuevo sitio de Internet donde puedes encontrar muchos freebies, los freebies son muestras gratis que te envian las empresas para probar sus productos.

Hay algunos que realmente valen la pena.
Aqui dejo la dirección:

http://www.muestrasgratismexico.blogspot.com/

Origenes de JAVA

2008-12-09T19:25:00.000-08:00

El uso principal que se hace de Internet e incluso de las redes internas (corporativas) es correo electrónico (e-mail), aunque actualmente hay un auge sorprendente de la navegación web . Los documentos web pueden contener variedad de texto, gráficos de todas clases y proporcionar enlaces hipertexto hacia cualquier lugar de la red. Los navegadores utilizan documentos escritos en lenguaje HTML. La combinación actual de navegadores HTML/WWW están limitados pues, a texto y gráficos. Si se quiere reproducir un sonido o ejecutar un programa de demostración, primero hemos de bajarnos (download) el fichero en cuestión y luego utilizar un programa en nuestro ordenador capaz de entender el formato de ese fichero, o bien cargar un módulo ( plug-in ) en nuestro navegador para que pueda interpretar el fichero que hemos bajado.
Hasta ahora, la única forma de realizar una página web con contenido interactivo, era mediante la interfaz CGI ( Common Gateway Interface ), que permite pasar parámetros entre formularios definidos en lenguaje HTML y programas escritos en Perl o en C. Esta interfaz resulta muy incómoda de programar y es pobre en sus posibilidades.
El lenguaje Java y los navegadores con soporte Java, proporcionan una forma diferente de hacer que ese navegador sea capaz de ejecutar programas. Con Java se puede reproducir sonido directamente desde el navegador, se pueden visitar home pages con animaciones, se puede enseñar al navegador a manejar nuevos formatos de ficheros, e incluso, cuando se pueda transmitir video por las líneas telefónicas, nuestro navegador estará preparado para mostrar esas imágenes.
Utilizando Java, se pueden eliminar los inconvenientes de la interfaz CGI y también se pueden añadir aplicaciones que vayan desde experimentos científicos interactivos de propósito educativo a juegos o aplicaciones especializadas para la televenta. Es posible implementar publicidad interactiva y periódicos personalizados. Por ejemplo, alguien podría escribir un programa Java que implementara una simulación química interactiva (una cadena de adn). Utilizando un navegador con soporte Java, un usuario podría recibir fácilmente esa simulación e interaccionar con ella, en lugar de conseguir simplemente un dibujo estático y algo de texto. Lo recibido cobra vida . Además, con Java podemos estar seguros de que el código que hace funcionar el experimento químico no contiene ningún trozo de código malicioso que dañe al sistema. El código que intente actuar destructivamente o que contenga errores, no podrá traspasar los muros defensivos colocados por las características de seguridad y robustez de Java.
Además, Java proporciona una nueva forma de acceder a las aplicaciones. El software viaja transparentemente a través de la red. No hay necesidad de instalar las aplicaciones, ellas mismas vienen cuando se necesitan. Por ejemplo, la mayoría de los navegadores del Web pueden procesar un reducido número de formatos gráficos (típicamente GIF y JPEG). Si se encuentran con otro tipo de formato, el navegador estándar no tiene capacidad para procesarlo, tendría que ser actualizado para poder aprovechar las ventajas del nuevo formato. Sin embargo, un navegador con soporte Java puede enlazar con el servidor que contiene el algoritmo que procesa ese nuevo formato y mostrar la imagen. Por lo tanto, si alguien inventa un nuevo algoritmo de compresión para imágenes, el inventor sólo necesita estar seguro de que hay una copia en código Java de ese algoritmo instalada en el servidor que contiene las imágenes que quiere publicar. Es decir, los navegadores con soporte Java se actualizan a sí mismos sobre la marcha, cuando encuentran un nuevo tipo de fichero o algoritmo.

Agenda

2008-05-23T17:55:00.001-07:00

// Fig. 17.7: Agenda.java

// A class that represents one record of information.

package com.deitel.jhtp5.ch17;

import java.io.Serializable;

public class AccountRecord implements Serializable {

private String nombre;

private String Direccion_S;

private String Ocupacion_S;

private String Correo_S;

private int Telefono_S;

public AccountRecord()

{

this( 0, "", "", 0.0 );

}

// initialize a record

public AccountRecord( String var_nombre, String var_Direccion, String var_ocupacion, String var_correo, int var_telefono )

{

setAccount( var_nombre );

setDireccion_S( var_Direccion );

setOcupacion_S( var_ocupacion );

setCorreo_S( var_correo );

setTelefono_S( var_telefono );

//setBalance( bal );

}

// set Nombre

public void setAccount( String var_nombre )

{//Instanciar la variable var_nombre a nombre

nombre = var_nombre;}

// get Nombre

public int getAccount()

{ return nombre; }

// set Direccion_S

public void setDireccion_S( String var_Direccion )

{

//Instanciar la variable var_Direccion a Direccion_S

Direccion_S = var_Direccion;}

// get Direccion_S

public String getDireccion_S()

{

return var_Direccion;

}

// set Ocupacion

public void setOcupacion_S( String var_ocupacion )

{

Ocupacion_S = var_ocupacion;

}

// get Ocupacion

public String getOcupacion_S()

{

return var_ocupacion;

// set Correo

public void setCorreo_S( String var_correo )

{

Correo_S = var_correo;

}

// get Correo

public String getCorreo_S()

{

return var_correo;

}

// set Telefono

public void setTelefono_S( int var_telefono )

{

Telefono_S = var_telefono;

}

// get account number

public int getTelefono_S()

{

return var_telefono;

}

} // Final de la Clase Agenda

// Fig. 17.6: BankUI.java

// A reusable GUI for the examples in this chapter.

package Agenda_Folder;

import java.awt.*;

import javax.swing.*;

public class BankUI extends JPanel {

// label text for GUI

protected final static String names[] = { "Nombre",

"Direccion", "Ocupacion", "Correo Electrónico", "Telefono", "Ardilla" };

// GUI components; protected for future subclass access

protected JLabel labels[];

protected JTextField fields[];

protected JButton doTask1, doTask2;

protected JPanel innerPanelCenter, innerPanelSouth;

protected int size; // number of text fields in GUI

// constants representing text fields in GUI

public static final int NOMBRE = 0, DIRECCION = 1, OCUPACION = 2,

CORREO = 3, TELEFONO = 4;

// Set up GUI. Constructor argument size determines the number of

// rows of GUI components.

public BankUI( int mySize )

{

size = mySize;

labels = new JLabel[ size ];

fields = new JTextField[ size ];

// create labels

for ( int count = 0; count <>

labels[ count ] = new JLabel( names[ count ] );

// create text fields

for ( int count = 0; count <>

fields[ count ] = new JTextField();

// create panel to lay out labels and fields

innerPanelCenter = new JPanel();

innerPanelCenter.setLayout( new GridLayout( size, 2 ) );

// attach labels and fields to innerPanelCenter

for ( int count = 0; count <>

innerPanelCenter.add( labels[ count ] );

innerPanelCenter.add( fields[ count ] );

}

// create generic buttons; no labels or event handlers

doTask1 = new JButton();

doTask2 = new JButton();

// create panel to lay out buttons and attach buttons

innerPanelSouth = new JPanel();

innerPanelSouth.add( doTask1 );

innerPanelSouth.add( doTask2 );

// set layout of this container and attach panels to it

setLayout( new BorderLayout() );

add( innerPanelCenter, BorderLayout.CENTER );

add( innerPanelSouth, BorderLayout.SOUTH );

validate(); // validate layout

} // end constructor

// return reference to generic task button doTask1

public JButton getDoTask1Button()

{

return doTask1;

}

// return reference to generic task button doTask2

public JButton getDoTask2Button()

{

return doTask2;

}

// return reference to fields array of JTextFields

public JTextField[] getFields()

{

return fields;

}

// clear content of text fields

public void clearFields()

{

for ( int count = 0; count <>

fields[ count ].setText( "" );

}

// set text field values; throw IllegalArgumentException if

// incorrect number of Strings in argument

public void setFieldValues( String strings[] )

throws IllegalArgumentException

{

if ( strings.length != size )

throw new IllegalArgumentException( "There must be " +

size + " Strings in the array" );

for ( int count = 0; count <>

fields[ count ].setText( strings[ count ] );

}

// get array of Strings with current text field contents

public String[] getFieldValues()

{

String values[] = new String[ size ];

for ( int count = 0; count <>

values[ count ] = fields[ count ].getText();

return values;

}

} // end class Bangui

// Fig. 17.8: CreateSequentialFile.java

// Writing objecst sequentially to a file with class ObjectOutputStream.

import java.io.*;

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import Agenda_Folder.BankUI;

import Agenda_Folder.AccountRecord;

public class CreateSequentialFile extends JFrame {

private ObjectOutputStream output;

private BankUI userInterface;

private JButton enterButton, openButton;

// set up GUI

public CreateSequentialFile()

{

super( "Creating a Sequential File of Objects" );

// create instance of reusable user interface

userInterface = new BankUI( 5 ); // four textfields

getContentPane().add( userInterface, BorderLayout.CENTER );

// configure button doTask1 for use in this program

openButton = userInterface.getDoTask1Button();

openButton.setText( "Guardar el archivo como..." );

// register listener to call openFile when button pressed

openButton.addActionListener(

// anonymous inner class to handle openButton event

new ActionListener() {

// call openFile when button pressed

public void actionPerformed( ActionEvent event )

{

openFile();

}

} // end anonymous inner class

); // end call to addActionListener

// configure button doTask2 for use in this program

enterButton = userInterface.getDoTask2Button();

enterButton.setText( "ENTER_SANDMAN" );

enterButton.setEnabled( false ); // disable button

// register listener to call addRecord when button pressed

enterButton.addActionListener(

// anonymous inner class to handle enterButton event

new ActionListener() {

// call addRecord when button pressed

public void actionPerformed( ActionEvent event )

{

addRecord();

}

} // end anonymous inner class

); // end call to addActionListener

// register window listener to handle window closing event

addWindowListener(

// anonymous inner class to handle windowClosing event

new WindowAdapter() {

// add current record in GUI to file, then close file

public void windowClosing( WindowEvent event )

{

if ( output != null )

addRecord();

closeFile();

}

} // end anonymous inner class

); // end call to addWindowListener

setSize( 500, 600 );

setVisible( true );

} // end CreateSequentialFile constructor

// allow user to specify file name

private void openFile()

{

// display file dialog, so user can choose file to open

JFileChooser fileChooser = new JFileChooser();

fileChooser.setFileSelectionMode( JFileChooser.FILES_ONLY );

int result = fileChooser.showSaveDialog( this );

// if user clicked Cancel button on dialog, return

if ( result == JFileChooser.CANCEL_OPTION )

return;

File fileName = fileChooser.getSelectedFile(); // get selected file

// display error if invalid

if ( fileName == null || fileName.getName().equals( "" ) )

JOptionPane.showMessageDialog( this, "Invalid File Name",

"Invalid File Name", JOptionPane.ERROR_MESSAGE );

else {

// open file

try {

output = new ObjectOutputStream(

new FileOutputStream( fileName ) );

openButton.setEnabled( false );

enterButton.setEnabled( true );

}

// process exceptions from opening file

catch ( IOException ioException ) {

JOptionPane.showMessageDialog( this, "Error Opening File",

"Error", JOptionPane.ERROR_MESSAGE );

}

} // end else

} // end method openFile

// close file and terminate application

private void closeFile()

{

// close file

try {

output.close();

System.exit( 0 );

}

// process exceptions from closing file

catch( IOException ioException ) {

JOptionPane.showMessageDialog( this, "Error closing file",

"Error", JOptionPane.ERROR_MESSAGE );

System.exit( 1 );

}

} // end method closeFile

// add record to file

public void addRecord()

{

String accountNumber = 0;

AccountRecord record;

String fieldValues[] = userInterface.getFieldValues();

// if account field value is not empty

if ( ! fieldValues[ BankUI.NOMBRE ].equals( "" ) ) {

// output values to file

try {

accountNumber = Integer.parseInt(

fieldValues[ BankUI.NOMBRE ] );

if ( accountNumber > 0 ) {

// create new record

record = new AccountRecord( accountNumber,

fieldValues[ BankUI.FIRSTNAME ],

fieldValues[ BankUI.LASTNAME ],

Double.parseDouble( fieldValues[ BankUI.BALANCE ] ) );

// output record and flush buffer

output.writeObject( record );

output.flush();

}

else

{

JOptionPane.showMessageDialog( this,

"Account number must be greater than 0",

"Bad account number", JOptionPane.ERROR_MESSAGE );

}

// clear textfields

userInterface.clearFields();

} // end try

// process invalid account number or balance format

catch ( NumberFormatException formatException ) {

JOptionPane.showMessageDialog( this,

"Bad account number or balance", "Invalid Number Format",

JOptionPane.ERROR_MESSAGE );

}

// process exceptions from file output

catch ( IOException ioException ) {

JOptionPane.showMessageDialog( this, "Error writing to file",

"IO Exception", JOptionPane.ERROR_MESSAGE );

closeFile();

}

} // end if

} // end method addRecord

public static void main( String args[] )

{

new CreateSequentialFile();

}

} // end class CreateSequentialFile

La cosa acerca de trabajar en la SDN

2008-05-19T21:16:00.001-07:00

La cosa acerca de trabajar en la SDN el contenido de la web del equipo - la multa que la gente lleva developers.sun.com, java.sun.com, la conferencia JavaOne sitio, y el contenido de la JavaOne Hoy periódico - es que mientras que usted está control de todos los períodos de sesiones, BOFs, y el aseado schwag en el Pabellón de palabra, estamos en cranking contenido. Normalmente, los que nos deja fuera de contacto sobre cualquier cosa que no está contenido en nuestro ritmo. Leemos de los demás artículos, y llenar los espacios en blanco de esa manera. Pero este año, es casi más fácil perder de vista el alcance de las cosas a través de la Web de lo que era en realidad para estar allí en la sala. La sesión general webcasts y repeticiones, disponibles en el sitio web de JavaOne, que todo el mundo que no había sido capaz de cuña su camino en la sala de envasados escuchar el mensaje de todos modos. Y aunque no llegué a respirar el mismo aire como Neil Young (sigh. ..), por lo menos llegué a oírlo hablar ... una y otra y otra vez. El Blog de actividad, tanto en la Conferencia y fuera de él, fue intensa. Hay blogs suficiente para llenar dos planetas: BlogCentral en sun.com y JavaOne 2008 sobre planets.sun.com. El actual evento JavaOne en SecondLife fue tremendo. Doce eventos durante cuatro días, sobre todo, desde JavaFX a OpenSolaris a NetBeans. Este fue el primer programa de JavaOne en el mundo, permitiendo a la gente que no puede unirse a nosotros en el Moscone a ser conectados, sin tener que viajar. Puede ser en cualquier parte del mundo, y aún así aprovechar los recursos disponibles en la conferencia JavaOne. ¿Cómo es que Verde? Y si los avatares no sólo fueron de corte por usted, el JavaOne contribuciones a YouTube eran bastante entretenida. El Sun Microsystems Noticias canal tiene algunos grandes cosas. Y, honestamente, el 'Java minuto de serie puede ser, en cierta forma, mejor que estar allí (no tener jostled, no data-room-only, no mochila en la cara ...). Aquí tienes un consejo: La atractiva Tommy Jr videos están en la SDN Total Access Net canal Dicho todo esto, hay algunas cosas que usted no puede conseguir a menos que usted está aquí. La JavaOne periódico Hoy, por ejemplo. Y amigos, tengo más divertido con la realización de los bits por el documento que para cualquier otra cosa que hago aquí. Las preguntas del día nos dio una idea de lo que estás pensando y lo que está participando en por ahí; el Daily Preguntas crack me, y la profundidad de contenido la cobertura nunca deja de salir me impresionó, no sólo con lo que está fuera hay que aprender, pero que la que hay que enseñar y escribir acerca de ello. Las cabinas de Trabajo sobre el Pabellón de suelo es también un buen rendimiento. La SDN stand se colocó así, por lo que no sólo tenemos la oportunidad de reunirse con muchos de ustedes, pero también fueron de pie sobre la alfombra cushier relleno - que, permítame decirle, ayudó a una tonelada. Ya sea hablando de la Web MySDN de demos y DocWeb, o la mecánica de la pequeña clicky-llave regalos, pasé la mayor parte de mi deber horas de risa, y de conocer a usted, que es una cosa maravillosa. Oye, que me fuera del sótano por unas cuantas horas! CommunityOne, convenientemente programada para antes de la verdadera locura JavaOne comienza para nuestro grupo, es realmente asombroso. La mayoría de la gente que conozco que asistieron a las sesiones libres en esta "pre-evento" se sigue tratando de integrar el proceso y lo que había oído, incluso días más tarde. Es una cosa hablar de o para el uso de código abierto, pero es otra muy distinta para discutir las filosofías y las bases de código abierto. "Libre" y "abierto" a fin de tener muchos significados diferentes, y es realmente inspirador ver a la gente participar en las conversaciones en torno a estas definiciones. No puede esperar a ver cómo continúan las discusiones en los blogs! Y lo que JavaOne sin ser como Rock Stars? Seleccionado por los asistentes, estos son individuos que están tan comprometidos con sus tecnologías, de modo entusiasta en sus presentaciones, que el pueblo votó por ellos como digno de mención. El superlativo Rock Star entrevista serie merece la pena leer a través, incluso si se cumplieron sus períodos de sesiones, por lo que sabe lo que debe priorizar en el próximo año calendario. Y hablando de Programación Builder, la SDN personal de pruebas, una manera de hacer que incluso mejor, a modo de microformatting. Descargue el Mozilla Firefox plug-in del operador, y el uso microformatos para ver el calendario de sesiones de JavaOne técnico con más detalle. Debido a los plazos, esto va a imprimir antes de que Dark Después evento, que promete ser espectacular. Pude haber perdido Neil Young en persona, pero usted puede apostar ¡ya existe para Smash Mouth. Así que si usted estuviera aquí en persona, prácticamente, o en el mundo, la tecnología Java fue allí también. Por lo tanto, muchas de las sesiones generales se dirigió a la ubicuidad de Java: Creo que la facilidad de acceso del contenido, no importa que el modo de participación que usted eligió, apoya precisamente eso. JAVA + USTED, conectado.

Origen de Java

2008-04-28T13:46:00.001-07:00

Introducción a Java

2008-04-28T13:38:00.000-07:00