lunes, 30 de noviembre de 2009
jueves, 26 de noviembre de 2009
Parámetros para feeds RSS
| Parámetro | Descripción | Valores admitidos | Ejemplo |
| max-results | Limita 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-index | Selecciona el primer resultado a mostrar. | 1, valorNumérico | ?start-index=26 |
| date | Limita los resultados al rango de fechas especificado | MMDDYYYY-MMDDYYYY | ?date=01011980-12311989 |
| sort | Especifica 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-max | Establece rango de resultados por fecha de publicación | Fecha en formato RFC3339 | ?published-max=2008-12-31 |
| updated-min, updated-max | Establece rango de resultados por fecha de actualización | Fecha 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
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:
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:
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":
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":
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"
- 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"
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"
- Pulsando la tecla F5
- Menú "Depurar > Continuar"
- Icono "Continuar"
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:
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:
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:
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.
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.
Si se desea mostrar qué tipo de error se ha producido se puede utilizar el método toString:
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.
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.{
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)
}
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:
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");
}
{
int num = Integer.valueOf(campoNúmero.getText());
}
catch(NumberFormatException e)
{
System.out.println("Error: El valor indicado no es un número");
}
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:
Donde se utilizan los siguientes elementos:
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:
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;
}
{
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.
- Inicializar la variable de control del bucle.
- 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.
- Continuar la ejecución del programa.
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:
El orden de ejecución de una sentencia do-while es la siguiente:
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.
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.{
BloqueDeSentencias;
} while (condición);
El orden de ejecución de una sentencia do-while es la siguiente:
- Ejecutar el bloque de sentencias.
- Evaluar la condición.
- Si el resultado es true, volver al punto 1.
- Si el resultado es false ir al punto 3.
- Continuar la ejecución del programa.
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;
}
{
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;
}
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.
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.
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:
El orden de ejecución de una sentencia while es la siguiente:
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:
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:
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.{
BloqueDeSentencias;
}
El orden de ejecución de una sentencia while es la siguiente:
- 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.
- 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:
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;
}
{
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;
}
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:
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):
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:
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:
Hay que destacar que la sección del valor default es opcional, como se ha podido ver también en los ejemplos anteriores.
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:{
case valorLiteral1:
BloqueSentencias1;
break;
case valorLiteral2:
BloqueSentencias2;
break;
case valorLiteralN:
BloqueSentenciasN;
break;
default:
BloqueSentenciasDefault;
}
- Obtener el resultado de la expresión.
- Comparar el resultado obtenido con valorLiteral1.
• Si son iguales:
• Ejecutar BloqueSentencias1.
• Saltar al paso 5. - Comparar el resultado obtenido con valorLiteral2.
• Si son iguales:
• Ejecutar BloqueSentencias2.
• Saltar al paso 5.
... - Comparar el resultado obtenido con valorLiteralN.
• Si son iguales:
• Ejecutar BloqueSentenciasN.
• Saltar al paso 5.
• En caso contrario:
• Ejecutar BloqueSentenciasDefault - Continuar con la ejecución del programa.
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);
//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);
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;
}
switch(letra)
{
case 'A':
num += 1;
case 'B':
num += 2;
break;
case 'C':
num += 3;
}
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";
}
{
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";
}
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.
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:
El formato de utilización es el siguiente:
La expresiónCondicional es una expresión cuyo resultado debe ser un valor boolean, es decir, true ó false. Por ejemplo:
El orden de ejecución de una sentencia if es el siguiente:
- Evaluar la condición que es una expresión condicional o booleana (resultando Verdadero o Falso).
- Si el resultado es Verdadero:
- Ejecutar la sentencia o bloque de sentencias incluidas dentro de esta estructura.
- 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;
}
sentencia2;
...
sentenciaN;
}
- 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");
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;
sentenciaSiEsTrue;
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");
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;
}
{
bloqueSentencias1;
}
else
{
bloqueSentencias2;
}
Por tanto, el orden de ejecución de una sentencia if-else es el siguiente:
- Evaluar la condición que es una expresión condicional o booleana (resultando Verdadero o Falso).
- Si el resultado es Verdadero:
- Ejecutar el primer bloque de sentencias incluidas dentro de esta estructura.
- Si el resultado es Falso:
- Ejecutar el segundo bloque de sentencias, detrás del else.
- 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");
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);
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);
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:
Por ejemplo, al obtener el texto de uno de esos componentes, podemos realizar operaciones como las siguientes:
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:
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.
El botón Calcular realizará el proceso de recoger el valor introducido, calcular el doble y mostrar el resultado:
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());
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());
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.
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));
}
{
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.
Nos centraremos en los componentes más elementales para la entrada y la salida de datos, que pueden ser:
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.
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.
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.
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.
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".
La definición del método setText es la siguiente:
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:
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.
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.
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:
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:
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).
La definición del método append es la siguiente:
Por ejemplo, si se desea añadir el texto "amigos" al que tuviera un área de texto llamado areaSaludo, se debe emplear la sentencia:
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:
Modificando los ejemplos anteriores para que sean válidos, quedarían como sigue:
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.
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:
Por ejemplo, se puede escribir:
- Etiquetas
- Campos de texto
- Áreas de texto
- Botones
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.
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.
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.
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");
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));
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
}
/** Creates new form Ventana */
public Ventana() {
initComponents();
//Escribe aquí los cambios iniciales del formulario
}
public Ventana() {
initComponents();
campoSaludo.setText("Hola");
}
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:
}
{
// TODO add your handling code here:
}
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:
private void botónModificarActionPerformed(java.awt.event.ActionEvent evt)
{
campoSaludo.setText("Bienvenido");
}
{
campoSaludo.setText("Bienvenido");
}
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
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:
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
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.
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);
Suscribirse a:
Entradas (Atom)
