www. La Mandarina Mecánica .es

Imagina que en función de un parámetro tuvieses que ejecutar una clase u otra, lo primero que se nos viene a la cabeza es hacer un IF-ELSE tantas veces como valores diferentes pueda tener el parametro y dentro de cada IF crear una instancia de la clase correspondiente, si por ejemplo el parámetro pudiese tomar 100 valores diferentes quedaría un IF inmenso y poco legible. Ejemplo1 (con 5 tareas usando IF-ELSE): continúe leyendo…

Hace poco os hablamos de la realidad aumentada en videojuegos, y pusimos Invizimals para PSP como ejemplo. Nintendo no se ha hecho esperar, y ha presentado en NDSi un impresionante juego en reales 3D, Rittai Kakushi e Attakoreda. Mediante la tecnología Head Tracking, esto es, seguimiento de la cabeza que esta delante de la cámara, la imagen gira y nos muestra las imágenes como si estuviéramos mirando dentro de una caja, de manera que según la perspectiva podemos encontrar la solución al acertijo. El resultado es prometedor:

De momento sólo estará disponible en la DSi Ware japonesa, esperemos que pronto esté en occidente.

En muchas aplicaciones Java, es muy frecuente que tengamos la necesidad de ejecutar tareas periódicamente, muchas pueden ser las razones que nos lleven a ello, llamar periódicamente a un script que actualice una BBDD, comprobar periódicamente ciertos datos de la BBDD y dependiendo de sus valores mostrar una alarma al usuario…

Si nos encontramos ante la necesidad de hacer un desarrollo de este tipo, tenemos múltiples opciones para afrontarlo, la solución ‘casera’ es que la propia API de Java nos proporciona utilidades para hacerlo, la otra solución es, como siempre, recurrir a librerías externas al API de Java, en este artículo vamos a utilizar la librería QUARTZ.

Veamos que nos ofrece la API de Java.

La API de Java nos ofrece las clases:

- java.util.Timer
- java.util.TimerTask

Clase Timer

La clase Timer nos permite ejecutar las tareas de una forma programada, cada Timer en realidad es un Thread de Java que ejecuta todas los TimerTask que tenga asignados secuencialmente.

Sus métodos más importantes son:
  Cancel( ): Termina el Timer descartando todas las tareas planificadas.
  Schedule( ): Planifica la tarea a ejecutar (Consultar  API para ver todas las opciones posibles).

Clase TimerTask

La clase TimerTask representa la tarea que se debe ejecutar periódicamente.
Para utilizarla tenemos que construir una clase que extienda de la clase TimerTask y sobreescribir el método run(), dentro de este método irá le código que queremos que se ejecute cuando se lance la tarea.
Sus métodos más importantes son:

  Run( ) : Este método es el que se sobreescribe para que la tarea ejecute nuestro código.
  Cancel( ): Desplanifica esta tarea (no se vuelve a ejecutar) pero no para el Timer que la ejecuta.

Mostrar el código del ejemplo.

continúe leyendo…

CUANDO TODO VA MAL…  (I)

Excepciones en JAVA, que son,  ¿como las controlamos?
   Cualquier programador intenta no cometer ningún tipo de error al “picar código”, pero la dura realidad es que por muy bueno que seamos,  los cometemos, para ello JAVA nos facilita una serie de clases para manipular excepciones, en los que podremos manipular tanto los propios errores que podamos cometer de lógica, como los derivados de un procesamiento condicional… huy que lio, vamos a explicarlo mejor.

Que salte una excepción no tiene porque ser síntoma de un error, necesariamente. Es simplemente una herramienta que nos facilita JAVA para localizar acontecimientos que requieren una atención especial, y un mecanismo que permita que el programa no falle.

   Podemos tratar con las clases genéricas de las que disponemos, o bien crear las nuestras  propias.  Si son excepciones comunes, como controlar un null  por ej, pues nos valdría con las que disponemos la clase Throwable, pero si necesitamos algo más complejo, reutilizable, y personalizado, os aconsejo crear la nuestra propia. Más adelante veremos unos ejemplos.

Podemos tener varios tipos de Excepciones:
     - Error de compilación. Si el código que introdujimos no era el correcto, por un error de sintaxis, de una simple coma que se nos cuele, JAVA se quejará y no será posible compilar. Suele ser un error de fácil lectura, puesto que se nos indica la línea y el carácter que originó el error. Un consejo para prevenir, todos los IDE tienen atajos a la hora de escribir los comandos, y desplegables  que son muy útiles.

     - Error en tiempo de ejecución. Hemos conseguido c ompilar nuestro programa, pero al ejecutarlo nos da error. Esto es porque por ejemplo, declaramos en nuestra BBDD un dato como String, y en el programa lo pasamos como Int. Son errores difíciles de detectar, porque nos obligan a estudiar el programa detenidamente.

   Para hacernos más liviana la tarea, como decía, JAVA nos facilita una serie de clases donde podremos capturar las Excepciones, y decirle a nuestro programa como debe de actuar.
   Todas ellas son Subclases de la clase Throwable. Cuando se emite una excepción, se crea un objeto derivado de esta clase, y se le pasa a la Máquina Virtual de Java para que la trate, con la palabra reservada Throw.
   Las dos Subclases principales de Throwable son Error y Exception. Siendo la primera para tratar errores que causarían una interrupción en el programa, mientras que Exception nos permitirá recogerla y tratarla siguiendo con el flujo del programa.

Estructura básica de un bloque try-catch-finally
try {
   // aquí incluiremos todo el código que pensemos que nos puede dar errores en tiempo de ejecución. Lo envolvemos todo entre los paréntesis.
 }
 catch (Excepcion e1) {
   // En caso de que salte una excepción, le especificaremos de que manera vamos actuar.
 }
 finally {
 // bloque de código que siempre se ejecutará aunque haya habido excepciones, por ejemplo cerrar un archivo
 }

   Bien vamos a ver un ejemplo sencillo de una excepción en una JSP, en donde vamos a intentar dividir un número entre 0.

<%@page contentType=”text/html” pageEncoding=”UTF-8″%>
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”
   “http://www.w3.org/TR/html4/loose.dtd“>

<html>
    <head>
        <meta http-equiv=”Content-Type” content=”text/html; charset=UTF-8″>
        <title>JSP Page</title>
    </head>
    <body>
      <%
        int i=10;  // declaramos unas variables de tipo entero, las damos
        int j=0;   // el valor y le hacemos la division…
       
        try{
       // i = i/j;   //
        }catch (Exception e) {
            out.println(”Ha ocurrido el siguiente error:<br>”);
            out.println(e.toString());
        }
      %>
      <p>El valor de i es <%=i%></p>

    </body>
</html>

   Descifrando mensajes de error.
   Como  consecuencia de realizar esa operación, veremos un esperado A Servlet Exception Has Ocurred, junto con el detonante de la excepción:  java.lang.ArithmeticException.
   Técnicamente a este mensaje se le conoce como una traza de pila:

Java.lang.ArithmeticException: /by zero
 At org.apache.jsp.error_0005fno0005fcatch_jsp._jspService
  (error_0005fno_0005fcatch_jsp.java:62)
 at org.apache.jasper.runtime.HttpJspBase.java:107
 at javax.servlet.http.HttpServlet.service(HttpServlet.java:853)
 at org.apache.jasper.servlet.JspServlet$JspServletWrapper.service(JspServlet.java:200)
 at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:379)
 at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:453)
 at javax.servlet.http.HttpServlet.service(HttpServlet.java:853)

 
    Bien, vamos a entender un poco este mensaje, que nos será de gran ayuda a la hora de determinar las causas de error.
Para empezar podemos ver cuál es la excepción remitida, en el ejemplo este es fácil, no indica que ha sido una “división entre 0”.
   Lo siguiente que nos indica es donde ocurrió el error. Como ya sabéis, cuando una JSP se ejecuta, se convierte en un Servlet (código JAVA) y es aquí donde ocurre el error, no en la JSP (ya sabéis, lo de “lado del cliente, y del servidor”).  Bien ya sabemos donde ocurrió el error, ahora queda ver en la que línea se originó: 62  (error_0005fno_0005fcatch_jsp.java:62).

   Si exploramos nuestra JSP, veremos que la línea 62 corresponde a  i =i / j ; Bien pues con esto ya sabríamos localizar que parte de nuestro código es el que falló.

   Este es un tema bastante largo, a la vez que interesante e útil, por lo que están casi apunto la continuación del artículo. Crear nuestra propia clase Exception, Depurar Errores usando Mozilla.

Marcos.

Tratare de darle forma a lo que es un gestor de diseño desde el punto de vista del “diseño”.

Estos pueden ser el estilo de visualización, que todos los componentes tengan el mismo estilo de visualización independientemente de la plataforma en la que se utilizan.

En java, dentro de AWT hay cinco gestores de diseño (FlowLayout, BorderLayout,  CardLayout, GridLayout, GridBagLayout), también puedes crear los tuyos propios.

Para trabajar con un gestor de diseño, se especifica el GDD y le añadimos componentes. 

FlowLayout, este además de ser el gestor de diseño por defecto de los applets, este es también el más simple de todos. Este agrupa los componentes de izquierda a derecha.

this.setLayout(new FlowLayout());

BorderLayout, este divide el container en cinco zonas norte, sur, este, oeste y deja una amplia zona

central para el resto de los componentes.

this.setLayout( new BorderLayout());

CardLayout, este permite varias tarjetas una encima de otra que abarcan todo el área (interactuables)

CardLayout gestor=new CardLayout();

setLayout (gestor)

GridLayout, este gestor distribuye los componentes basándose en una rejilla bidimensional. Un componente por celda.

setLayout(new GridLayout(4,3))

GridBagLayout el último y a su vez el más potente. Similar al anterior pero permite mas de una celda por componente.

GridBagLayout gestor=new GridBagLayout();

(Si vas a utilizar este gestor de diseño no dejes tienes que ver como funciona GridBagConstraints).

Como hemos dicho anteriormente, en cualquiera de los casos, tendrás que añadir los componentes con el Método add().

add(new Button(”componente uno”));

add(new Button(”componente dos”));

add(new Button(”componente tres”));

…

Para utilizar el método add() tenemos que tener un componente de la clase contenedor (Panel,Window,Frame,Dialog,FileDialog).

En este caso será Frame y para añadir elementos a un componente contenedor se debe utilizar el método add() de la clase container.

import java.awt.*;

 

public class  Ventana extends Frame{

   public Button boton;       

   public static void main (String[] args){

   Ventana instanciaV = new Ventana(”Titulo”,200,200);       

   }    

  public Ventana(String nombre,int x ,int y){

     super(nombre);

     setSize(x,y);

     setVisible(true);      

     boton=new Button(”The button”);             this.add(boton);    //Utilizamos el método add()

      }     

}

Podemos crear dialogos con la Clase Dialog  (esta está dentro de AWT).
Un Dialog puede ser modal, es decir puede no permitir ir a la otra ventana hasta que esta se cierre.
En el ejemplo creamos una Ventana y llamamos al metodo que crea un dialogo.

import java.awt.*;

public class  Ventana extends Frame{
 
 public static void main (String[] args){
 Ventana instanciaV = new Ventana(”Titulo”,200,200); 
 instanciaV.dialogEmergente(”Emergente”,120 ,120);
 } 
 public Ventana(String nombre,int x , int y){
  super(nombre);
  setSize(x,y);
  setVisible(true);  
 }
 public void dialogEmergente(String titulo, int x , int y){
  Dialog di = new Dialog(this,titulo,true);
  di.setSize(x, y);
  di.setVisible(true);  
 }     }

Con la clase FileDialog , podemos abrir el típico cuadro de diálogo. Algo así:

 public void dialogEmergente(int x , int y){
  FileDialog di = new FileDialog(this);
  di.setSize(x, y);
  di.setVisible(true);  
 }

En el ejemplo: creamos un constructor para la ventana y le pasamos tres argumentos.

import java.awt.*;
public class  Ventana extends Frame{
   
    public static void main (String[] args){
    Ventana instanciaV = new Ventana(”Titulo”,200,200);   
    }   
    public Ventana(String nombre,int x , int y){
        super(nombre);
        setSize(x,y);
        setVisible(true);       
    }
}

Con la clase Runtime podemos interactuar la aplicación con el sistema operativo,  hay que tener cuidado pues podemos  perder la independencia o portabilidad que tiene Java. 

public class Class1{

public void calculadora(){

try{

Runtime.getRuntime().exec(”calc.exe”);

}

catch(java.io.IOException ex){}

}

public static void main (String[] args){

Class1 objClass1=new Class1();

objClass1.calculadora();

}
}

Ejemplo , en el que se ejecuta la calculadora de Windows