jueves, 26 de noviembre de 2009

Parámetros para feeds RSS

Parámetro
Descripción
Valores admitidos
Ejemplo
max-resultsLimita el número máximo de resultados. El valor por defecto es 25. El valor máximo es 100.
25, 1-100?max-results=25
start-indexSelecciona el primer resultado a mostrar.
1, valorNumérico?start-index=26
dateLimita los resultados al rango de fechas especificado
MMDDYYYY-MMDDYYYY?date=01011980-12311989
sortEspecifica el orden de los resultados
relevance, date_ascending, date_descending?sort=date_ascending
category
Limita los resultados a la categoría especificada
cualquierCategoría
?category=ejemplo
orderby
Ordena los resultados según la fecha de publicación o de actualización
published, updated
?orderby=updated
alt
Formato de salida
atom, rss, json, json-in-script
?alt=rss
published-min published-maxEstablece rango de resultados por fecha de publicación
Fecha en formato RFC3339
?published-max=2008-12-31
updated-min, updated-maxEstablece rango de resultados por fecha de actualizaciónFecha en formato RFC3339?updated-max=2008-12-31
callback
Usado con json-in-script para especificar el nombre de la función callback



Utilización:
http://blogname.blogspot.com/feeds/posts/default?....

Para obtener sólo los de una etiqueta:
http://blogname.blogspot.com/feeds/posts/default/-/labelname

Para obtener sólo los de varias etiquetas
http://blogname.blogspot.com/feeds/posts/default/-/labelname1/labelname2

Para obtener sólo los comentarios
http://blogname.blogspot.com/feeds/comments/default

Vectores

http://javiergarbedo.es/index.php/apuntes/31-arrays/124-vectores

Arrays

http://javiergarbedo.es/index.php/apuntes/31-arrays/123-arrays

lunes, 23 de noviembre de 2009

Depuración de programas con NetBeans

La depuración (debug) permite examinar las aplicaciones para buscar errores, ya que posibilita observar las líneas que se van ejecutando, así como los valores que van tomando las variables en cada paso.

Para realizar la depuración de un programa, se debe establecer en primer lugar un punto de interrupción donde debe pararse la ejecución de la aplicación. Esto se consigue con alguna de las siguientes acciones sobre la línea de código en la que se desee establecer el punto de interrupción:
  • Clic en el margen izquierdo
  • Menú contextual > "Ocultar/Mostrar línea de punto de interrupción"
  • Pulsando la combinación de teclas: Ctrl + F8
  • Menú "Depurar > Ocultar/Mostrar línea de punto de interrupción"
Al realizar alguna de esas acciones, se marca en color rosado la línea que se ha convertido en un punto de interrupción, y se muestra un pequeño cuadrado en el margen izquierdo.

debug01
Una vez establecido al menos un punto de interrupción, se debe ejecutar la aplicación en modo depuración. Esto se puede llevar a cabo sobre el proyecto o sólo sobre el archivo actual:
  • Depurar archivo actual:
    • Menú contextual > "Debug nombreArchivo"
    • Menú "Depurar > Debug nombreArchivo"
    • Pulsando la combinación de teclas: Ctrl + Mayúsculas + F5
  • Depurar proyecto:
    • Menú "Depurar > Debug Main Project"
    • Icono "Debug Main Project"
      debug02
Al llegar la ejecución de la aplicación al punto de interrupción establecido, se destaca en color verde la línea de código en la que se encuentre la ejecución.

debug03
En la parte inferior se muestra la ventana de observación de las variables locales, en la que se puede comprobar el valor que va tomando cada variable.

A partir del momento en que se para la ejecución del programa se puede continuar con la ejecución línea a línea utilizando la opción "Continuar ejecución":
  • Pulsando la tecla F8
  • Menú "Depurar > Continuar ejecución"
  • Icono "Continuar ejecución"
    debug04
Así se va mostrando en verde la línea que se va ejecutando en cada momento, y se van actualizando en la ventana inferior los valores que van tomando las variables locales.

debug05
En caso de que se desea que el programa continúe la ejecución sin más paradas, se dispone de la opción "Continuar":
  • Pulsando la tecla F5
  • Menú "Depurar > Continuar"
  • Icono "Continuar"
    debug06

jueves, 19 de noviembre de 2009

Control de excepciones

Una excepción es un evento que ocurre durante la ejecución de un programa y detiene el flujo normal de la secuencia de instrucciones del programa.

El control de dichas excepciones se utiliza para la detección y corrección de errores. Si hay un error, la aplicación no debería "morirse".

Para manejar las excepciones en Java, se actúa de la siguiente manera:
  • Se intenta (try) ejecutar la sentencia o bloque de sentencias que pueden producir algún error.
  • Se captura (catch) las posibles excepciones que se hayan podido producir, ejecutando una serie de sentencias que informen o intenten resolver el error.
  • Finalmente (finally) se puede ejecutar una serie de sentencias tanto si se ha producido un error como si todo ha ido bien.
Se debe utilizar el siguiente formato:

    try
    {
        Sentencias que pueden producir error
    }
    catch(ClaseExcepción variableRecogeExcepción)
    {
        Sentencias que informan o procuran solucionar el error.
        Puede haber varios catch.
        La variable no se tiene declarar antes.
    }
    finally
    {
        Sentencias que deben ejecutarse en cualquier caso (opcional)
    }
El elemento ClaseExcepción que aparece junto a catch, debe ser una de las clases de excepción que utiliza Java. Al generarse el error durante la ejecución podemos comprobar qué clase de excepción se ha producido. De forma general, la clase Exception recoge todos los tipos de excepciones. Si se desea un control más exhaustivo del tipo de error que se produce, se debe concretar más la clase de excepción correspondiente.

Por ejemplo, cuando se intenta convertir al tipo de dato numérico entero un dato introducido por el usuario en un campo de texto se utiliza una sentencia como:
    int num = Integer.valueOf(campoNúmero.getText());
Si el valor introducido no es numérico, sino una cadena de caracteres, la llamada a Integer.valueOf produce una excepción, como se puede apreciar en la salida estándar:

try01
Se puede apreciar que se produce una excepción del tipo NumberFormatException, por tanto se debería captura esa excepción para controlar el error.

        try
        {
            int num = Integer.valueOf(campoNúmero.getText());
        }
        catch(NumberFormatException e)
        {
            System.out.println("Error: El valor indicado no es un número");
        }
Si no se tiene claro el tipo de excepción que se quiere controlar, o se quiere controlar cualquier tipo de excepción que se pueda producir, se puede indicar en el catch la clase Exception que es genérica para todas las excepciones, tal como se ha indicado anteriormente.
        try
        {
            int num = Integer.valueOf(campoNúmero.getText());
        }
        catch(Exception e)
        {
            System.out.println("Se ha detectado un error");
        }
Si se desea mostrar qué tipo de error se ha producido se puede utilizar el método toString:

            System.out.println(e.toString);



lunes, 9 de noviembre de 2009

Sentencia for

La sentencia for se caracteriza porque permite repetir un bloque de instrucciones un número de veces fijado de antemano.

Utiliza una variable contador que parte de un valor inicial, se incrementa un según un valor de incremento establecido, y al superar un valor final prefijado se finalizará la ejecución del bucle.

Se debe utilizar el siguiente formato:

    for (Inicialización; Condición; Incremento)
    {

        BloqueDeSentencias;
    }

Donde se utilizan los siguientes elementos:
  • Inicialización: Una sentencia de asignación (o varias separadas por comas) donde la variable de control del bucle toma un valor inicial.
  • Condición: Mientras esta expresión condicional valga true se repetirá el bucle. Se evaluará al inicio de cada repetición del bucle.
  • Incremento: Sentencia (o sentencias) que actualiza la variable de control incrementándola o decrementándola.
El orden de ejecución de una sentencia for es la siguiente:
  1. Inicializar la variable de control del bucle.
  2. Evaluar la condición.
    • Si el resultado es true:
      • Ejecutar BloqueDeSentencias.
      • Incrementar o decrementar la variable de control según la instrucción indicada en Incremento.
      • Volver al punto 2.
    • Si el resultado es false:
      • Ir al punto 3.
  3. Continuar la ejecución del programa.
Ejemplo: Mostrar los 10 primeros números múltiplos de 7.

public class EjemploFor {

    public static void main(String[] args) {
        for(int i=1; i<=10; i++)
            System.out.println(i*7);
    }

}
La instrucción for es una forma compacta de representar un bucle while, siendo la estructura equivalente a la anterior, la presentada a continuación:

        int i=1;
        while(i<=10)
        {
            System.out.println(i*7);
            i++;
        }

Sentencia do-while

La sentencia do-while se caracteriza porque permite repetir un bloque de instrucciones varias veces, ejecutándose obligatoriamente al menos 1 vez. Por lo que se puede ver que es muy similiar a la sentencia while, con la diferencia del número mínimo de veces que se ejecuta el bloque de instrucciones que contiene.

La condición que se establece se evalúa después de ejecutar el bloque de instrucciones que contiene la instrucción do-while.

Se debe utilizar el siguiente formato:

    do
    {
       BloqueDeSentencias;
    } while (condición);
Como siempre, si el bloque de sentencias está formado por una única sentencia, se puede prescindir de las llaves, y hay que destacar que termina con un punto y coma, a diferencia de la sentencia while.

El orden de ejecución de una sentencia do-while es la siguiente:
  1. Ejecutar el bloque de sentencias.
  2. Evaluar la condición.
    • Si el resultado es true, volver al punto 1.
    • Si el resultado es false ir al punto 3.
  3. Continuar la ejecución del programa.
Ejemplo: Generar la secuencia de números siguiente: 1 2 4 7 11 16 22 etc. En ella, se va incrementando cada vez una unidad más respecto a la anterior. La secuencia se debe generar hasta que se alcance el valor máximo que indique el usuario:

ejemploWhile
public class EjemploDoWhile extends javax.swing.JFrame
{

    public EjemploDoWhile()
    {
        initComponents();
    }

    /* Código generado automáticamente no mostrado */

    private void botónGenerarActionPerformed(java.awt.event.ActionEvent evt)                                            
    {                                                
        int numMax = Integer.valueOf(campoMáximo.getText());
        int numActual = 1;
        int incremento = 1;
       
        areaMensajes.setText("");
        do
        {
            areaMensajes.append(String.valueOf(numActual) + " ");
            numActual+=incremento;
            incremento++;
        }while (numActual <= numMax);
    }                                            

    public static void main(String args[])
    {
        java.awt.EventQueue.invokeLater(new Runnable()
        {

            public void run()
            {
                new EjemploDoWhile().setVisible(true);
            }
        });
    }

    private javax.swing.JTextArea areaMensajes;
    private javax.swing.JButton botónGenerar;
    private javax.swing.JTextField campoMáximo;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JScrollPane jScrollPane1;
}
En este ejemplo conviene observar que si el usuario introduce el valor 0 o cualquier valor negativo, el programa entrará una vez en el bloque de sentencias de la instrucción do-while, mostrando el valor 1.

jueves, 29 de octubre de 2009

Sentencia while

La sentencia while permite la ejecución de un bloque de sentencias de forma repetitiva. El bloque de sentencias se ejecutará repetidamente mientras se cumpla una determinada condición, la cual será una expresión booleana. Si al evaluar la condición resulta true, el bloque se sentencias se ejecutará, y se repetirá su ejecución hasta que la condición resulte false.

Este tipo de sentencias, que permiten la repetición de un bloque de sentencias, reciben también el nombre de bucles.

Es importante tener controlada la salida del bucle, de forma que si entra en él, debe cumplirse en algún momento que la condición resulte false para que termine el bucle. Si no ocurriera esto, el bucle sería infinito y el programa dejaría de responder.

La sentencia while se caracteriza porque permite repetir un bloque de instrucciones de 0 a varias veces. La condición que se establece se evalúa antes de ejecutar el bloque de instrucciones que contiene la instrucción Mientras. Si el resultado de la expresión resulta Falso el bloque de instrucciones no se ejecutará ninguna vez.

Se debe utilizar el siguiente formato:

    while (condición)
    {
       BloqueDeSentencias;
    }
Como siempre, si el bloque de sentencias está formado por una única sentencia, se puede prescindir de las llaves.

El orden de ejecución de una sentencia while es la siguiente:
  1. Evaluar la condición.
    • Si el resultado es true, ejecutar el bloque de sentencias de la estructura while y volver al punto 1.
    • Si el resultado es false ir al punto 2.
  2. Continuar la ejecución del programa.

Las expresiones condicionales que se indican en los paréntesis del while suelen ser expresiones relacionales que resultan valores lógicos (true o false) o cualquier otra expresión que también resulte un valor booleano, por ejemplo:
  • while (num > 0)
  • while (letra == 'N' || letra == 'n')
  • while (num >= 0 && num <=100)
  • while (!cadena.equalsIgnoreCase("fin"))

Ejemplo: Generar la secuencia de números siguiente: 1 2 4 7 11 16 22 etc. En ella, se va incrementando cada vez una unidad más respecto a la anterior. La secuencia se debe generar hasta que se alcance el valor máximo que indique el usuario:

ejemploWhile

public class EjemploWhile extends javax.swing.JFrame
{

    public EjemploWhile()
    {
        initComponents();
    }

    /* Código generado automáticamente no mostrado */

    private void botónGenerarActionPerformed(java.awt.event.ActionEvent evt)
    {
        int numMax = Integer.valueOf(campoMáximo.getText());
        int numActual = 1;
        int incremento = 1;
        while (numActual <= numMax)
        {
            areaMensajes.append(String.valueOf(numActual) + " ");
            numActual+=incremento;
            incremento++;
        }
    }

    public static void main(String args[])
    {
        java.awt.EventQueue.invokeLater(new Runnable()
        {

            public void run()
            {
                new EjemploWhile().setVisible(true);
            }
        });
    }

    private javax.swing.JTextArea areaMensajes;
    private javax.swing.JTextField campoMáximo;
    private javax.swing.JButton botónGenerar;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JScrollPane jScrollPane1;
}
En este ejemplo conviene observar que si el usuario introduce el valor 0 o cualquier valor negativo, el programa no entrará ninguna vez en el bloque de sentencias de la instrucción while.

martes, 27 de octubre de 2009

Sentencia switch

La sentencia switch permite la ejecución de un determinado bloque de código según el valor que tome una variable o expresión que se indique.

El formato de utilización es el siguiente:

    switch(expresión)
    {
        case valorLiteral1:
            BloqueSentencias1;
            break;
        case valorLiteral2:
            BloqueSentencias2;
            break;
        case valorLiteralN:
            BloqueSentenciasN;
            break;
        default:
            BloqueSentenciasDefault;
    }
La secuencia de ejecución es la siguiente:
  1. Obtener el resultado de la expresión.
  2. Comparar el resultado obtenido con valorLiteral1.
           • Si son iguales:
                 • Ejecutar BloqueSentencias1.
                 • Saltar al paso 5.
  3. Comparar el resultado obtenido con valorLiteral2.
           • Si son iguales:
                 • Ejecutar BloqueSentencias2.
                 • Saltar al paso 5.
    ...
  4. Comparar el resultado obtenido con valorLiteralN.
           • Si son iguales:
                 • Ejecutar BloqueSentenciasN.
                 • Saltar al paso 5.
           • En caso contrario:
                 • Ejecutar BloqueSentenciasDefault
  5. Continuar con la ejecución del programa.
Hay que tener en cuenta que el resultado de la expresión debe ser uno de los tipos de datos básicos (byte, short, int, long float, double, char y boolean), por lo que no se puede utilizar, por ejemplo, con cadenas de caracteres String.

Ejemplo de uso para obtener el nombre del día de la semana según el número de orden del día de la semana (1 a 7):

        String textoDíaSemana;

        //Obtener el número de día de la semana escrito por el usuario
        int numDía = Integer.valueOf(campoDía.getText());

        switch(numDía)
        {
            case 1:
                textoDíaSemana = "Lunes";
                break;
            case 2:
                textoDíaSemana = "Martes";
                break;
            case 3:
                textoDíaSemana = "Miércoles";
                break;
            case 4:
                textoDíaSemana = "Jueves";
                break;
            case 5:
                textoDíaSemana = "Viernes";
                break;
            case 6:
                textoDíaSemana = "Sábado";
                break;
            case 7:
                textoDíaSemana = "Domingo";
                break;
            default:
                textoDíaSemana = "Incorrecto";
        }
       
        //Mostrar el nombre del día en un campo de texto
        campoNombreDía.setText(textoDíaSemana);
La instrucción break; impide que, tras ejecutar las sentencias de un determinado bloque, se ejecuten seguidamente las sentencias del bloque siguiente.

Por ejemplo, observemos el siguiente trozo de código:

        int num = 1;
        switch(letra)
        {
            case 'A':
                num += 1;
            case 'B':
                num += 2;
                break;
            case 'C':
                num += 3;
        }
En ese ejemplo, si la letra es 'A' el resultado de num es 4, porque se inicializa al valor 1, al coincidir la letra con 'A' se le suma 1 y al no encontrase un break continúa sumándole 2. En cambio, si la letra es 'B', el resultado de num es 3, ya que parte del valor 1 y sólo se le suma 2, no sumándole el 3 de la letra 'C' por encontrar un break.

Si se desea que un mismo bloque de código se ejecute para varios valores literales, se utilizará un case para cada valor, escribiendo el bloque de código detrás del último case:

        switch(letra)
        {
            case 'a':
            case 'e':
            case 'i':
            case 'o':
            case 'u':
                textoMensaje = "Vocal minúscula";
                break;
            case 'A':
            case 'E':
            case 'I':
            case 'O':
            case 'U':
                textoMensaje = "Vocal mayúscula";
        }
Hay que destacar que la sección del valor default es opcional, como se ha podido ver también en los ejemplos anteriores.

Portales de descarga de software libre

  • Open Source Living (Organizado por categorías)
  • Open Source Alternative (Alternativas al software comercial organizado por categorías y nombres de aplicaciones comerciales)
  • AlternativeTo (Buscardor de alternativas a cualquier aplicación. Secciones de Windows, Linux, Mac y Online)

Sitios de descarga de versiones antiguas de software

Hay ocasiones en que una versión antigua de un determinado programa puede funcionar mejor que las últimas actualizaciones. Esto puede ocurrir con datos guardados en esas versiones anteriores, porque nuestro ordenador no soporta nuevos requisitos, etc.

Ahí va una serie de sitios donde se pueden conseguir versiones antiguas. El inconveniente es que están en Inglés.

lunes, 26 de octubre de 2009

Sentencia if y sentencia if-else

La sentencia if permite ejecutar un bloque de instrucciones si se cumple una determinada condición.

El orden de ejecución de una sentencia if es el siguiente:
  1. Evaluar la condición que es una expresión condicional o booleana (resultando Verdadero o Falso).
  2. Si el resultado es Verdadero:
    • Ejecutar la sentencia o bloque de sentencias incluidas dentro de esta estructura.
  3. Continuar la ejecución del programa a partir de la siguiente instrucción que se encuentra fuera de la estructura de la sentencia if.

El formato de utilización es el siguiente:

    if(expresiónCondicional)
    {
        sentencia1;
        sentencia2;
        ...
        sentenciaN;

    }
La expresiónCondicional es una expresión cuyo resultado debe ser un valor boolean, es decir, true ó false. Por ejemplo:
  • num > 0
  • sexo=='H' && edad > 18

El conjunto de sentencias que se encuentran entre las llaves (sentencia1, sentencia2, ..., sentenciaN) es una serie de instrucciones que pueden ser cualquiera de las que pueden ser utilizadas en otro lugar del código fuente (asignar valores a variables, llamar a métodos como mostrar datos u obtener datos del teclado, otras sentencias if, etc). Esas sentencias sólo se ejecutarán en caso de que la expresiónCondicional valga true en el momento en que es evaluada.

Ejemplo:
    //Obtener un número por teclado
    num = Integer.valueOf(campoDato.getText());

    //Comprobar si el número introducido es distinto de cero
    if(num != 0)
    {
        //Las siguientes instrucciones sólo se ejecutan
        //   si el valor de la variable num no es cero
        areaMensajes.append("El número introducido no es cero");
        resultado = valor / num;
        campoResultado = setText(String.valueOf(resultado));
    }

    //A partir de aquí, las siguientes instrucciones se ejecutan siempre
    areaMensajes.append("Fin del programa");

En caso de que el bloque de sentencias que se encuentre dentro de la sentencia if sólo esté formado por una solo sentencia, no es necesaria la utilización de las llaves.

    if(expresiónCondicional)
         sentenciaSiEsTrue;
Ejemplo:
    num = Integer.valueOf(campoDato.getText());

    if(num != 0)
        areaMensajes.append("El número introducido no es cero");

    //A partir de aquí, las siguientes instrucciones se ejecutan siempre
    areaMensajes.append("Fin del programa");

También es posible especificar además un bloque de sentencias que debe ejecutarse en el caso contrario, es decir, cuando el resultado de evaluar la expresiónCondicional es false. Para ello debe usarse la estructura if-else, cuyo formato es el siguiente:

    if(expresiónCondicional)
    {
        bloqueSentencias1;
    }
    else
    {

        bloqueSentencias2;
    }
El bloque de sentencias llamado bloqueSentencias1 sólo se ejecutará si el resultado de evaluar la expresiónCondicional es true, y el bloqueSentencias2 sólo se ejecutará si el resultado de evaluar la expresiónCondicional es false.

Por tanto, el orden de ejecución de una sentencia if-else es el siguiente:
  1. Evaluar la condición que es una expresión condicional o booleana (resultando Verdadero o Falso).
  2. Si el resultado es Verdadero:
    • Ejecutar el primer bloque de sentencias incluidas dentro de esta estructura.
  3. Si el resultado es Falso:
    • Ejecutar el segundo bloque de sentencias, detrás del else.
  4. Continuar la ejecución del programa a partir de la siguiente instrucción que se encuentra fuera de la estructura de la sentencia if-else.

Al igual que en la estructura anterior, si alguno de los bloques de sentencias sólo está formado por una instrucción, se puede prescindir de las llaves en ese bloque.

Ejemplo:
    //Obtener un número por teclado
    num = Integer.valueOf(campoDato.getText());

    //Comprobar si el número es positivo o negativo
    if(num < 0)
    {
        //Instrucciones que se ejecutan si num < 0
        areaMensajes.append("El número introducido es negativo");
    }
    else
    {
        //Instrucciones que se ejecutan si NO se cumple num < 0
        areaMensajes.append("El número introducido es positivo");
    }

    //A partir de aquí, las siguientes instrucciones se ejecutan siempre
    areaMensajes.append("Fin del programa");

Dentro de cada bloque de sentencias asociadas al if o al else también pueden aparecer otras estructuras if o if-else. El problema con el que nos podemos encontrar en este tipo de estructuras, es en el momento de anidar varias sentencias if o if-else, pues resulta difícil saber qué else está asociado con qué if, por ello hay que tener en cuenta la siguiente regla: Una sentencia else siempre está asociada con el if precedente más próximo, siempre que no tenga ya asociada otra sentencia else.

Ejemplos de if-else anidados:
//EJEMPLO 1
    if (a > b)
        System.out.println(a);
    if (c > a)
        System.out.println(c);
    else  //Corresponde a if(c>a)
        System.out.println(b);

//EJEMPLO 2
    if (a > b)
    {
        System.out.println(a);
    if (c > a)
        System.out.println(c);
    }
    else  //Corresponde a if(a>b)
        System.out.println(b);

//Este mismo ejemplo 2 queda mucho más claro si se usa adecuadamente el sangrado:
    if (a > b)
    {
        System.out.println(a);
        if (c > a)
            System.out.println(c);
    }
    else  //Corresponde a if(a>b)
        System.out.println(b);
En estos ejemplos hay que observar que las estructuras son prácticamente idénticas, pero el bloque asociado al else se ejecuta en distintas situaciones en cada caso, como se puede observar en los comentarios.

sábado, 17 de octubre de 2009

Obtener datos a través de formularios

La operación de recoger datos que han sido introducidos por el usuario en un formulario es muy frecuente. Una vez obtenidos los datos serán procesados de alguna manera en el código fuente y se mostrarán los resultados obtenidos.

Los componentes más básicos para la recogida de información son los Campos de texto (JTextField) y las Áreas de texto (JTextArea) que permiten al usuario escribir un texto en ellos, diferenciándose en que en las áreas de texto se pueden escribir varias líneas de texto.

La obtención del texto que ha sido escrito por el usuario, a través de código fuente se lleva a cabo utilizando el método getText() sobre esos tipos de componentes.

La definición del método getText es la siguiente:
String getText()
donde se puede observar que no se le pasa ningún parámetro y retorna un String con el contenido del texto que se encuentra escrito en el Campo de texto o el Área de texto sobre el que se aplique dicho método.

Por ejemplo, al obtener el texto de uno de esos componentes, podemos realizar operaciones como las siguientes:
        //Guardar el texto en una variable String
        String saludo;
        saludo = campoSaludo.getText();
       
        //Mostrar el texto en la salida estándar
        System.out.print("Ha escrito: " + campoSaludo.getText());
       
        //Mostrar el texto en otro campo de texto
        campoResultado.setText(campoSaludo.getText());
       
        //Convertir el texto en tipo numérico
        int valorNumérico;
        valorNumérico = Integer.valueOf(campoSaludo.getText());
Conviene recordar que la información que se recoge de los JTextField y JTextArea son cadenas de caracteres (String), por lo que si se desea operar con esos datos de forma numérica, deben ser convertidas al tipo de dato numérico deseado con el método valueOf:
Integer valueOf(String s)
Long valueOf(String s)
Float valueOf(String s)
Double valueOf(String s)
El método valueOf producirá un error durante la ejecución del programa si la cadena de caracteres no se puede convertir al tipo indicado, por ejemplo, si contiene alguna letra.

Como ejemplo vamos a ver cómo se realizaría el cálculo del doble de un valor numérico introducido por el usuario:

La ventana contiene campoNúmero sonde el usuario indicará un número, y campoResultado donde se mostrará el doble del valor escrito.
entrada01
El botón Calcular realizará el proceso de recoger el valor introducido, calcular el doble y mostrar el resultado:
    private void botónCalcularActionPerformed(java.awt.event.ActionEvent evt)
    {
        String textoIntroducido, textoDoble;
        int numIntroducido, valorDoble;
        //Recoger el dato introducido por el usuario
        textoIntroducido = campoNúmero.getText();
        //Convertirlo a tipo numérico
        numIntroducido = Integer.valueOf(textoIntroducido);
        //Calcular el doble
        valorDoble = numIntroducido * 2;
        //Convertir el resultado a texto
        textoDoble = String.valueOf(valorDoble);
        //Mostrar el resultado
        campoResultado.setText(textoDoble);
       
        //Todo lo anterior se podría escribir en una solo línea:
        //campoResultado.setText(String.valueOf(Integer.valueOf(campoNúmero.getText())*2));
    }

jueves, 15 de octubre de 2009

Mostrar datos a través de formularios

La introducción de datos por parte del usuario y la visualización de resultados se puede realizar a través de diversos componentes que se pueden encontrar en la "Paleta" que se muestra en la vista "Diseño" de los formularios.
salida01
Nos centraremos en los componentes más elementales para la entrada y la salida de datos, que pueden ser:
  • Etiquetas
  • Campos de texto
  • Áreas de texto
  • Botones
Las Etiquetas permiten mostrar textos e imágenes de forma estática, es decir, el usuario no puede modificar su contenido directamente.

Los Campos de texto y las Áreas de textos permiten que el usuario pueda escribir un texto en ellos, aunque pueden modificarse sus propiedades para que no sean editables y únicamente muestren resultados. Se diferencian en que los campos de texto sólo permiten escribir una única línea de texto, mientras que las áreas de texto pueden contener varias líneas.

Los Botones permiten realizar una determinada acción cuando el usuario hace clic sobre ellos. La acción que se lleve a cabo será la que se programa en el código fuente que se escriba asociado a dicho botón.
salida02
Cualquiera de estos componentes pueden incluirse en el diseño del formulario seleccionándolo en la paleta y colocándolo en el lugar deseado del formulario, o bien arrastrándolo desde la misma paleta.
salida03
Al mover el componente sobre el formulario, se puede observar que aparecen varias guías en forma de líneas azules para situarlo más fácilmente de forma alineada con cualquier otro objeto del formulario.

Por defecto, los componentes tienen un tamaño predefinido que puede ser modificado a través de los pequeños cuadros que aparecen en sus esquinas y laterales al seleccionarlo dentro del formulario. Haciendo clic sobre cualquiera de esos cuadros se puede modificar el tamaño del componente arrastrando el ratón en la dirección deseada.

Además, cuando se selecciona un componente dentro del formulario, se muestra otro tipo de guías que son azules punteadas y terminadas en un pequeño semicírculo. Esas guías indican con qué otro componente está anclado. Con esto de consigue que si la ventana cambia de tamaño, el componente seguirá anclado de la forma que indique esta guía.
salida04
En la imagen se puede observar que el botón está anclado al margen izquierdo e inferior de la ventana, por lo que al agrandar la ventana durante la ejecución (imagen derecha), se puede observar que el botón sigue anclado a esas posiciones.

Además todos los componentes tienen asociado un nombre de variable, que será utilizado en el código fuente del programa para hacer cualquier modificación del componente durante la ejecución de la aplicación. Por defecto, tienen un nombre predefinido formado por el tipo de componente seguido de un número, por ejemplo: jLabel1, jTextField3, jButton2. El nombre de la variable puede modificarse abriendo el menú contextual sobre el componente seleccionado y eligiendo la opción "Cambiar Nombre de la Variable". El nombre de variable que se asigne debe seguir las normas generales de nombres de variables en Java, y es recomendable incluir en el nombre el tipo de componente al que hace referencia, por ejemplo: campoApellidos, botónAceptar.
salida05
Cada uno de los componentes mencionados tienen un texto por defecto que muestran al colocarlos en el formulario. Ese texto puede ser modificado durante el diseño del formulario abriendo el menú contextual (botón derecho del ratón) sobre el componente seleccionado y eligiendo la opción "Editar Texto".
salida06

Método setText

Ese texto que muestran estos componentes también puede ser modificado durante la ejecución del programa. Para ello se debe utilizar una llamada al método setText que tienen los componentes Etiquetas (JLabel), Campos de texto (JTextField), Áreas de texto (JTextArea) o botones (JButton) que estamos utilizando.

La definición del método setText es la siguiente:
void setText(String t)
Es decir, que hay que pasarle un parámetro (entre paréntesis) de tipo String, y no retorna nada (void) tras hacer la llamada a este método.

Por ejemplo, para cambiar el texto de un campo de texto cuya variable asociada es campoSaludo para que contenga el texto "Hola" se puede emplear la sentencia:
        campoSaludo.setText("Hola");
Se puede observar que, al escribir la línea anterior utilizando el entorno de desarrollo NetBeans, en el momento de escribir el punto (.) si se espera un pequeño instante aparece la lista de métodos que se pueden emplear con el tipo de objeto que se está empleado antes del punto, y en el que además se muestran los parámetros que deben usarse y el tipo de valor que retorna. Según se van escribiendo letras, la lista va filtrando los métodos que comienzan con las letras escritas, y es posible elegir un método de la lista pulsando la tecla Intro tras seleccionarlo.
salida07
El parámetro que se le pasa al método setText puede ser cualquier valor de tipo String, es decir, no sólo puede ser el valor literal de una cadena de texto, también puede ser una variable de tipo String, cualquier expresión que resulte una cadena de texto o la llamada a un método que retorne un String.

        String cadena = "Prueba";
        campoSaludo.setText("Hola");
        campoSaludo.setText("Hola " + "amigos míos");
        campoSaludo.setText("Resultado: " + 3743);
        campoSaludo.setText(cadena);
        campoSaludo.setText(cadena + " de código");
        campoSaludo.setText(cadena.toUpperCase());        
        campoSaludo.setText(String.valueOf(237.8743));

Mostrar información al abrir el formulario

Si se desea que el cambio del texto que muestra uno de estos componentes se realice en el momento de iniciarse el programa (al abrirse el formulario), estas sentencias deben incluirse detrás de la sentencia initComponents(); que aparece automáticamente al crear el formulario en su código fuente.

public class Ventana extends javax.swing.JFrame {

    /** Creates new form Ventana */
    public Ventana() {
        initComponents();
        //Escribe aquí los cambios iniciales del formulario
    }
salida08
En la imagen se puede apreciar que el campo de texto, durante el diseño tiene el texto "jTextField1", pero al abrir la ventana el texto cambia a "Hola", ya que se ha modificado el código fuente detrás de initComponentes(); de la siguiente manera:
    public Ventana() {
        initComponents();
        campoSaludo.setText("Hola");
    }

Mostrar datos al pulsar un botón

Si se desea que el texto varíe al producirse un evento, se debe incluir la llamada al setText en el método asociado al evento deseado. Por ejemplo, si se desea modificar el texto de un componente al hacer clic en un botón, en primer lugar se debe crear el evento de acción sobre el botón. La manera más sencilla es haciendo doble clic sobre el botón. De esta forma aparece automáticamente un nuevo método con un código como éste:

    private void botónAceptarActionPerformed(java.awt.event.ActionEvent evt)
    {
        // TODO add your handling code here:
    }
En el comentario mostrado se indica el lugar en el que se debe escribir el código que debe ejecutarse cuando se haga clic sobre el botón.

Por ejemplo, si se desea modificar el texto de un componente llamado campoSaludo para que muestre el texto "Bienvenido" al hacer clic sobre un botón llamado botónModificar, se debe escribir el siguiente código:
salida09

    private void botónModificarActionPerformed(java.awt.event.ActionEvent evt)
    {
        campoSaludo.setText("Bienvenido");
    }
En la imagen se puede apreciar que al ejecutar la ventana (imagen derecha) el campo de texto no se ha modificado, pero tras pulsar el botón el texto ha cambiado (imagen inferior).

Método append

Los componentes de área de texto (JTextArea), además del método setText, disponen del método append, el cual permite añadir texto al que ya tuviera anteriormente el área de texto. Hay que recordar que el método setText elimina el texto que tuviera anteriormente el componente sobre el que se aplica.

La definición del método append es la siguiente:
void append(String str)
Como se puede apreciar es muy similar a la estructura del método setText. Se le pasa como parámetro un String y no retorna nada.

Por ejemplo, si se desea añadir el texto "amigos" al que tuviera un área de texto llamado areaSaludo, se debe emplear la sentencia:
        areaSaludo.append("amigos");

Mostrar datos numéricos

Hay que destacar que tanto al método setText como el append sólo se le puede indicar como parámetro un valor de tipo String, es decir, una cadena de caracteres, por lo que algo como esto no es válido:
        campoResultado.setText(3467);  //No es válido
        int num = 29734;
        campoResultado.setText(num);   //No es válido
        campoResultado.setText(num * 4);   //No es válido

Por tanto, si se desea mostrar un valor numérico en uno de los componentes de un formulario se debe emplear el método valueOf de la clase String al que se le puede pasar por parámetro cualquier valor numérico (int, long, float o double) y lo convierte al tipo String, ya que dispone de las siguiente definiciones:
String valueOf(int i)
String valueOf(long l)
String valueOf(float f)
String valueOf(double d)
Modificando los ejemplos anteriores para que sean válidos, quedarían como sigue:
        campoResultado.setText(String.valueOf(3467));  //Sí es válido
        int num = 29734;
        campoResultado.setText(String.valueOf(num));   //Sí es válido
        campoResultado.setText(String.valueOf(num * 4));   //Sí es válido
        campoResultado.setText("Resultado = " + num);   //Sí es válido
        campoResultado.setText("" + num);   //Sí es válido

Campos no editables

Por defecto, el contenido de los campos de texto y de las áreas de texto puede ser modificado por el usuario cuando ejecuta el programa. Si se desea sólo se pueda modificar el contenido desde el código fuente o desde el diseño, se debe cambiar la propiedad "Editable" del campo de texto o del área de texto.

Durante el diseño del formulario se puede acceder a las propiedades de un campo o área de texto desde su "menú contextual > Propiedades" o desde la ventana "Propiedades" de la parte derecha. Ahí se puede encontrar la propiedad "Editable" con una casilla que de forma predeterminada aparece marcada. Si no se desea que el contenido del campo o área de texto pueda modificarse por el usuario, deberá desmarcarse esa casilla.
salida10

salida11
También es posible modificar esa propiedad utilizando una sentencia que puede llamarse, por ejemplo, después del initComponents(); para que tenga efecto desde que se abra la ventana. Se debe utilizar el método setEditable cuya definición es:
void setEditable(boolean b)
Se puede ver que se le debe indicar un parámetro de tipo boolean, de tal manera que si el parámetro es false, el campo no se podrá editar y si es true sí se podrá modificar por el usuario.
Por ejemplo, se puede escribir:
        campoSaludo.setEditable(false);





 

Contador de visitas