Conversiones

De cadena a numérico

public class Consola {
    public static void main(String [] args)
    {      
        String cadena ="5";
        int numero = Integer.parseInt(cadena);

        System.out.println(numero);
    }
}


De cadena a float

public class Consola {
    public static void main(String [] args)
    {
        String cadena ="5.5";
        float numero= Float.parseFloat(cadena);

        System.out.println(numero);
    }
}

De numerico a cadena

public class Consola {
    public static void main(String [] args)
    {
        int numero = 500;
        String cadena = String.valueOf(numero);

        System.out.println(cadena);
    }
}

Estructura de control

a.) La sentencia if - else

La sentencia if-else de Java dota a los programas de la habilidad de ejecutar distintos conjuntos de sentencias según algún criterio.

La sintaxis de la sentencia if-else es:


if ( condición )
  Bloque de código a ejecutar si la condición es cierta
else
  Bloque de código a ejecutar si la condición es falsa


La parte del else es opcional, y un bloque de código puede ser simplemente la sentencia vacía ; para representar que en ese caso no se ha de ejecutar nada.

Supongamos que un programa debe realizar diferentes acciones dependiendo de si el usuario oprime el botón aceptar o el botón cancelar en una ventana de dialogo. Nuestro programa puede realizar esto usando la sentencia if - else:


public class Consola {
    public static void main(String [] args)
    {
        boolean respuesta=true;
        if (respuesta == true) {
          System.out.println( "Su peticion esta siendo atendida" );
        } else {
          System.out.println( "Cancelando accion" );
        }
    }
}


Se pueden anidar expresiones if-else, para poder implementar aquellos casos con múltiples acciones. Esto es lo que se suele denominar como sentencias else if.

Por ejemplo, supongamos que se desea escribir un programa que clasifique según el contenido de una variable valor, asigne una letra a una variable clasificacion: A para un valor del 100-91, B de 90-81, C para 80-71 y F si no es ninguno de los anteriores:

public class Consola {
    public static void main(String [] args)
    {

       int valor=80;
       char clasificacion;
       if (valor > 90)
          {clasificacion='A';}
       else
          if (valor > 80)
            {clasificacion='B';}
          else
            if (valor > 70)
              {clasificacion='C';}
            else
              {clasificacion='F';}
       System.out.println(clasificacion);

    }
}


Se pueden escribir los if en las mismas líneas que los else, pero desde este tutorial se insta a utilizar la forma indentada (como se ha podido ver en el ejemplo), pues es más clara para el lector.

Este sistema de programación (else if) no es demasiado recomendable, y por ello el lenguaje Java incluye la sentencia switch, que veremos a continuación, para dirigir el flujo de control de variables con múltiples valores.


b.) La sentencia switch

Mediante la sentencia switch se puede seleccionar entre varias sentencias según el valor de cierta expresión.

La forma general de switch es la siguiente:

switch ( expresionMultivalor ) {
  case valor1 : conjuntoDeSentencias; break;
  case valor2 : conjuntoDeSentencias; break;
  case valor3: conjuntoDeSentencias; break;
  default: conjuntoDeSentencias; break;
}


La sentencia switch evalúa la expresiónMultivalor y ejecuta el conjuntoDeSentencias que aparece junto a la cláusula case cuyo valor corresponda con el de la expresiónMultivalor.

Cada sentencia case debe ser única y el valor que evalúa debe ser del mismo tipo que el devuelto por la expresiónMultivalor de la sentencia switch.

Las sentencias break que aparecen tras cada conjuntoDeSentencias provocan que el control salga del switch y continúe con la siguiente instrucción al switch. Las sentencias break son necesarias porque sin ellas se ejecutarían secuencialmente las sentencias case siguientes. Existen ciertas situaciones en las que se desea ejecutar secuencialmente algunas o todas las sentencias case, para lo que habrá que eliminar algunos break.

Finalmente, se puede usar la sentencia default para manejar los valores que no son explícitamente contemplados por alguna de las sentencias case. Su uso es altamente recomendado.

Por ejemplo, supongamos un programa con una variable entera meses cuyo valor indica el mes actual, y se desea imprimir el nombre del mes en que estemos. Se puede utilizar la sentencia switch para realizar esta operación:

public class Consola {
    public static void main(String [] args)
    {

       int meses=10;

        switch (meses){
          case 1: System.out.println( "Enero" ); break;
          case 2: System.out.println( "Febrero" ); break;
          case 3: System.out.println( "Marzo" ); break;
          case 4: System.out.println( "Abril" ); break;
          case 5: System.out.println( "Mayo" ); break;
          case 6: System.out.println( "Junio" ); break;
          case 7: System.out.println( "Julio" ); break;
          case 8: System.out.println( "Agosto" ); break;
          case 9: System.out.println( "Septiembre" ); break;
          case 10: System.out.println( "Octubre" ); break;
          case 11: System.out.println( "Noviembre" ); break;
          case 12: System.out.println( "Diciembre" ); break;
          default: System.out.println( "Mes no valido" ); break;
        }
     
    }
}



Por supuesto, se puede implementar esta estructura como una sentencia if else if:

int meses;
if ( meses == 1 ) {
  System.out.println( "Enero" );
} else
  if ( meses == 2 ) {
    System.out.println( "Febrero" );
  }
  // Y así para los demás meses


El decidir si usar la sentencia if o switch depende del criterio de cada caso. Se puede decidir cuál usar basándonos en la legibilidad, aunque se recomienda utilizar switch para sentencias con más de tres o cuatro posibilidades.

c.) Bucle while

El bucle while es el bucle básico de iteración. Sirve para realizar una acción sucesivamente mientras se cumpla una determinada condición.

La forma general del bucle while es la siguiente:

while ( expresiónBooleana ) {
  sentencias;
};


Las sentencias se ejecutan mientras la expresiónBooleana tenga un valor de verdadero.

Se utiliza, por ejemplo para estar en un bucle del que no hay que salir hasta que no se cumpla una determinada condición. Por ejemplo, multiplicar un número por 2 hasta que sea mayor que 100:

public class Consola {
    public static void main(String [] args)
    {
        int i = 1;
        while ( i <= 100 ) {
            i = i * 2;
            System.out.println(i);
        }
    }
}

Con él se podrían eliminar los bucles do-while y for por ser extensiones de éste, pero que se incluyen en el lenguaje para facilitar la programación.


d.) Bucle do-while

El bucle do-while es similar al bucle while, pero en el bucle while la expresión se evalúa al principio del bucle y en el bucle do-while la evaluación se realiza al final.

La forma general del bucle do-while es la siguiente:

do {
  sentencias;
} while ( expresiónBooleana );

La sentencia do-while es el constructor de bucles menos utilizado en la programación, pero tiene sus usos, cuando el bucle deba ser ejecutado por lo menos una vez.

Por ejemplo, cuando se lee información de un archivo, se sabe que siempre se debe leer por lo menos un carácter:

public class Consola {
    public static void main(String [] args)
    {

        int c;
        c=5;
        do {
          System.out.println(c);
          c--;
        } while(c>0);

    }
}

e.) Bucle for

Mediante la sentencia for se resume un bucle do-while con una iniciación previa. Es muy común que en los bucles while y do-while se inicien las variables de control de número de pasadas por el bucle, inmediatamente antes de comenzar los bucles. Por eso el bucle for está tan extendido.

La forma general de la sentencia for es la siguiente:

for ( iniciación ; terminación ; incremento )
  sentencias;

La iniciación es una sentencia que se ejecuta una vez antes de entrar en el bucle.

La terminación es una expresión que determina cuándo se debe terminar el bucle. Esta expresión se evalúa al final de cada iteración del bucle. Cuando la expresión se evalúa a falso, el bucle termina.

El incremento es una expresión que es invocada en cada iteración del bucle. En realidad puede ser una acción cualquiera, aunque se suele utilizar para incrementar una variable contador:

for ( i = 0 ; i < 10 ; i++ )

Algunos (o todos) estos componentes pueden omitirse, pero los puntos y coma siempre deben aparecer (aunque sea sin nada entre sí).

Se debe utilizar el bucle for cuando se conozcan las restricciones del bucle (su instrucción de iniciación, criterio de terminación e instrucción de incremento).

Por ejemplo, los bucles for son utilizados comúnmente para iterar sobre los elementos de una matriz, o los caracteres de una cadena:

public class Consola {
    public static void main(String [] args)
    {

        for ( int i = 0; i < 5 ; i++){
            System.out.println(i);
        }

    }
}

Excepciones

Vamos a hablar un poco sobre las Excepciones en Java, que son?, de donde vienen? y como evitarlas entre, otras....... debemos tener presente que siempre estamos propensos a encontrarnos con errores o Excepciones cuando estamos desarrollando, por eso de la importancia de conocerlas y saber como tratarlas....

Básicamente una excepcion es un Objeto descendiente de la clase java.lang.Object, podemos pensar en ellas como una condición excepcional en nuestro sistema el cual altera la correcta ejecución del mismo, las excepciones nos indican que hay algo anómalo,  inconsistente o simplemente un Error, lo cual impide que el sistema se ejecute como debería de ser...

Tal vez se preguntaran si ¿pero Anómalo, inconsistente o Error no es básicamente lo mismo?...... podría ser, pero en este enfoque no necesariamene lo es, ya que lo que vamos a conocer como una excepcion no siempre es un error (hablando como excepcion en general, ya que en java una Exception es muy diferente a un Error), muchas veces necesitaremos trabajar con excepciones controladas para indicar alguna inconsistencia en nuestro sistema que podría provocar errores.......

A modo de ejemplo, podemos encontrarnos con el famoso NullPointerException el cual nos indica que un objeto se encuentra vació, pero esto no es un error ya que nosotros podemos trabajar con objetos null, entonces veamoslo como si la excepcion nos dijera "Es un objeto nulo y no se puede efectuar el proceso", mientras que hay errores como NoClassDefFoundError el cual nos indica que la maquina virtual de Java (JVM) no puede encontrar una clase que necesita, debido a por ejemplo que no encuentra un .class, esto si se maneja como un error en java


La importancia de Prever!!!

Cuando se esta programando debemos tener claro que nuestro código no es perfecto, así tengamos mucha experiencia en desarrollo siempre esta la posibilidad de que algo falle, sea por nuestro código o por otros factores, por eso de la importancia de contemplar todo desde antes, posibles fallos o lo que pueda afectar el sistema.

Veamos un ejemplo Simple:

public class Consola {
    public static void main(String [] args)
    {
        int dividendo=4;
        int divisor=2;
        int resultado=dividendo/divisor;
        System.out.println(resultado);
    }
}

el main teóricamente esta bien, claro, a simple vista si tenemos : dividendo = 4 y divisor = 2 pues el resultado es 2 ......básico....... pero y si el divisor es 0? pues con ese caso puntual el resultado seria el siguiente.


Vemos que nos indican que se produjo una ArithmeticException debido a una división por cero, además se muestra cual fue la traza del error pasando por el método main hasta el metodoDividir().


La anterior es una Excepcion simple, algo que se supone no debería pasar, es obvio, no se puede dividir por cero, o ¿no?.........pues no, en programación no podemos asumir ni pensar así, ya que muchas veces nos olvidamos de las cosas obvias y las pasamos por alto, el problema es que eso tan obvio puede detener toda la ejecución del programa.


Trabajando con try - catch - finally

con los bloques Try - Catch podemos capturar y procesar una posible excepcion, evitando que el sistema se detenga sin necesidad cuando el motivo de esto puede ser corregido facilmente, la estructura básica es la siguiente.

try {
  //Bloque de código que vamos a procesar
} catch(excepcion) {
  //Tratamiento que se le da a la posible excepción
} finally {
  //Bloque de código que se ejecutará despues del try o del catch
}


Apliquemos esto a nuestro ejemplo anterior...

public class Consola {
    public static void main(String [] args)
    {

        int dividendo=4;
        int divisor=2;
        int resultado=0;
        try {
            resultado=dividendo/divisor;
        }catch (Exception e) {
            System.out.println("Se intentó dividir por cero");
        } finally{
            System.out.println(resultado);  
        }
     
    }

}

Como vimos aplicamos la estructura de los bloques y de esta manera nos aseguramos que la excepción anterior fue controlada evitando que el sistema se detenga, en el catch podemos hacer el proceso que consideremos conveniente, ya sea solo informar del error o solicitar nuevos parámetros de entrada.


Algunas Consideraciones.

Veamos un poco mas lo que debemos tener en cuenta cuando usamos estos bloques:

try : Aquí vamos a escribir todo el bloque de código que posiblemente llegue a lanzar unas excepción la cual queremos manejar, aquí va tanto el código como llamados a métodos que puedan arrojar la excepción.

En este bloque solo se detectara la primera excepcion lanzada, hay que tener en cuenta que por cada try se debe especificar un catch y/o un finally.

catch : en caso de que en el try se encuentre alguna excepción, se ingresara automaticamente al bloque catch donde se encontrara el código o proceso que queremos realizar para controlar la excepción.

Se pueden especificar cualquier cantidad de catch de ser necesario, estos deben ser ubicados después del try y antes del finally (en caso de que este ultimo se especifique),  cada catch que se ponga debe manejar una excepcion diferente (no se puede repetir) y el orden de estos depende de la jerarquía de herencia que se tenga, ingresando al primer catch que pueda suplir la necesidad a corregir, por ejemplo.

try {
      //Sentencias con posibles errores;
    } catch(InterruptedException e){
      //manejo de la exepcion
    } catch(IOException e){
   //manejo de la exepcion
    } catch(Exception e){
   //manejo de la exepcion
    }

Si se genera una excepción en el try, se valida a cual de los 3 catch se ingresa, dependiendo si InterruptedException puede controlarlo se ingresa a esa, sino entonces a IOException o si no a la superClase que seria Exception (ver la jerarquía de herencia anterior).

En el ejemplo que del metodoDividir() trabajamos directamente con Exception e, de esta forma nos aseguramos que capture cualquier excepción, sin embargo se recomienda usar la jerarquía en los catch para poderle dar un mejor manejo.

finally : Este bloque es opcional, lo podremos si queremos ejecutar otro proceso después del try o el catch, es decir, siempre se ejecutara sin importar que se encuentre o no una excepción, a menos que exista un return en alguno de los bloques anteriores.

Hilos

A veces necesitamos que nuestro programa Java realice varias cosas simultáneamente. Otras veces tiene que realizar una tarea muy pesada, por ejemplo, consultar en el listín telefónico todos los nombres de chica que tengan la letra n, que tarda mucho y no deseamos que todo se quede parado mientras se realiza dicha tarea. Para conseguir que Java haga varias cosas a la vez o que el programa no se quede parado mientras realiza una tarea compleja, tenemos los hilos (Threads).

Crear un Hilo

Crear un hilo en java es una tarea muy sencilla. Basta heredar de la clase Thread y definir el método run(). Luego se instancia esta

public class Consola {
    public static void main(String [] args)
    {

        Runnable miRunnable = new Runnable() {
            public void run() {
                //----------------------------------------
                for(int i=0;i<=10;i++){
                    System.out.println(i);
                    try {
                        Thread.sleep (1000);
                    } catch (Exception e) { }
                }
                //----------------------------------------
            }          
        };
        Thread hilo = new Thread(miRunnable);
        hilo.start();

    }
}

Listo. Hemos creado una clase hilo que hereda de Thread y con un método run(). En el método run() pondremos el código que queremos que se ejecute en un hilo separado. Luego instanciamos el hilo con un new hilo() y lo arrancamos con hilo.start(). El System.out que hay detrás se ejecutará inmediatamente después del start(), haya terminado o no el código del hilo.

Imprimir en Java

Se trata de un programa que recibe un String en un campo de texto y lo imprime al pulsar el botón IMPRIMIR.

/********************************************************************
* El siguiente programa es un ejemplo bastante sencillo de *
* impresión con JAVA. *
********************************************************************/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;


/********************************************************************
* La siguiente clase llamada "Impresora", es la encargada de   *
* establecer la fuente con que se va a imprimir, de obtener el *
* trabajo de impresion, la página. En esta clase hay un método *
* llamado imprimir, el cual recibe una cadena y la imprime. *
********************************************************************/
class Impresora
{
    Font fuente = new Font("Dialog", Font.PLAIN, 10);
PrintJob pj;
Graphics pagina;


/********************************************************************
* A continuación el constructor de la clase. Aquí lo único que *
* hago es tomar un objeto de impresion. *
********************************************************************/
Impresora()
{
pj = Toolkit.getDefaultToolkit().getPrintJob(new Frame(), "SCAT", null);
}

/********************************************************************
* A continuación el método "imprimir(String)", el encargado de *
* colocar en el objeto gráfico la cadena que se le pasa como *
* parámetro y se imprime. *
********************************************************************/
    public void imprimir(String Cadena)
{
//LO COLOCO EN UN try/catch PORQUE PUEDEN CANCELAR LA IMPRESION
try
{
pagina = pj.getGraphics();
pagina.setFont(fuente);
pagina.setColor(Color.black);

pagina.drawString(Cadena, 60, 60);

pagina.dispose();
pj.end();
}catch(Exception e)
{
System.out.println("LA IMPRESION HA SIDO CANCELADA...");
}
}//FIN DEL PROCEDIMIENTO imprimir(String...)


}//FIN DE LA CLASE Impresora



//A CONTINUACION LA CLASE PRINCIPAL
public class Programa extends JFrame
{
String cadena;
JTextField campo;
JButton imprimir;
JLabel info;
Impresora imp;
JPanel principal = new JPanel(new BorderLayout());
JPanel etiq = new JPanel(new FlowLayout());
JPanel dos = new JPanel(new FlowLayout());

//CONSTRUCTOR DE LA CLASE
Programa()
{
super("Muestra Simple de Impresión en JAVA...");

info = new JLabel("ESCRIBA ALGO EN EL CAMPO Y HAGA CLIC EN IMPRIMIR...");
cadena = new String();
campo = new JTextField(30);
imprimir = new JButton("IMPRIMIR");

dos.add(campo);
dos.add(imprimir);
etiq.add(info);

campo.setToolTipText("ESCRIBA ALGO AQUÍ...");
imprimir.setToolTipText("CLIC AQUI PARA IMPRIMIR...");

principal.add(etiq, BorderLayout.NORTH);
principal.add(dos, BorderLayout.CENTER);

getContentPane().add(principal);

//AJUSTO EL TAMAÑO DE LA VENTANA AL MINIMO
pack();
//NO PERMITO QUE PUEDAN CAMBIAR EL TAMAÑO DE LA VENTANA
this.setResizable(false);

//AHORA LA CENTRARÉ EN LA PANTALLA
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();

this.setLocation(((pantalla.width - cuadro.width)/2),
 (pantalla.height - cuadro.height)/2);


//LE AGREGAMOS EL EVENTO AL BOTON "imprimir"

imprimir.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
cadena = "";
cadena = String.valueOf(campo.getText());
if (!cadena.equals(""))
{
imp = new Impresora();
imp.imprimir(cadena);
}
else System.out.println("NO SE IMPRIME NADA EN BLANCO...");

campo.requestFocus();
campo.select(0, cadena.length());
}
});
 

 
}//FIN DEL CONSTRUCTOR

public static void main(String jm[])
{
Programa p = new Programa();
p.show();

p.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
}//FIN DEL MAIN



}//FIN DE LA CLASE PRINCIPAL

Esperar un tiempo en java

Normalmente se hacen todas las sentencias seguidas, pero a veces se necesita congelar el tiempo.

Pero como se hace para esperar un tiempo en una aplicación en Java antes de lanzar la siguiente sentencia…

Sencillo, imagina que quieres esperar 10 segundos entre una sentencia y otra. Para conseguirlo deberemos hacer lo siguiente:

Sentencia 1

try {
Thread.sleep (10000);
} catch (Exception e) {
// Mensaje en caso de que falle
}

Sentencia 2

Sencillo, ¿no?

El tiempo que se le pasa tiene que ser en milisegundos. También se puede crear un método Java que nos haga esto.

public void esperar (int segundos) {
try {
Thread.sleep (segundos*1000);
} catch (Exception e) {
// Mensaje en caso de que falle
}
}

Y ya tendremos un método Java al que le pasaremos los segundos a esperar.

JBLAS

JBLAS son un conjunto de librerías JavaBeans, que nos permite trabajar con base de datos (MySQL y PostgreSQL), su forma de trabajo es muy similar a la que trabajábamos con Visual FoxPro o Visual Basic, de esta manera programar conexiones y actualización de datos se hace muy fácil, las librerías aun están en versión beta, y las liberare muy pronto, espero comentarios y si desean usarlas solo pídanlas