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





miércoles, 7 de octubre de 2009

Operaciones básicas con cadenas de caracteres

Siendo cadena una variable de tipo String, se pueden realizar las siguientes operaciones:
  • cadena.charAt(pos): Devuelve el carácter que se encuentra en la posición pos que se indica como parámetro, dentro de cadena. El primer carácter de la cadena corresponde a la posición 0.
    • Ejemplo: "hola".charAt(1) equivale a 'o'.

  • cadena.compareTo(otraCadena): Compara cadena con otraCadena y devuelve:
    • 0: si son iguales.
    • >0: si cadena es mayor que otraCadena.
    • <0: si cadena es menor que otraCadena.

  • cadena.compareToIgnoreCase(otraCadena): Hace lo mismo que compareTo pero sin tener en cuenta las diferencias de mayúsculas y minúsculas.

  • cadena.concat(otraCadena): Concatena otraCadena detrás de cadena.
    • Ejemplo "cad".concat("ena") equivale a "cadena".

  • cadena.equals(otraCadena): Devuelve true si cadena es igual que otraCadena y false en caso contrario.

  • cadena.equalsIgnoreCase(otraCadena): Hace lo mismo que equals pero sin tener en cuenta las diferencias de mayúsculas y minúsculas.

  • cadena.length(): Devuelve el número de caracteres que forman la cadena.

  • cadena.replace(antChar, nuevoChar): Sustituye cada aparición del carácter antChar por nuevoChar en la cadena.

  • cadena.substring(posInicio, posFin): Devuelve una subcadena de cadena, formado por los caracteres que hay desde la posición posInicio hasta posFin-1.
    • Ejemplo: "hamburguesa".substring(4, 8) devuelve "urgu".

  • cadena.toLowerCase(): Convierte la cadena a minúsculas.

  • cadena.toUpperCase(): Convierte la cadena a mayúsculas.

  • cadena.valueOf(número): Convierte el valor numérico de número a una cadena de caracteres.
Todos los métodos de la clase String los puedes encontrar en la API de Java.

El resultado obtenido tras la ejecución de cualquiera de estos métodos puede asignarse a una variable que debe ser del mismo tipo de dato que el tipo de resultado obtenido, o integrarlo dentro de una expresión. También puede ser utilizado el resultado para mostrarlo en pantalla.

Ejemplos:
public class claseString {

    public static void main(String[] args) {
        String saludo = "hola";
        String cadenaResultado;
        int valorResultado;
        char caracterResultado;
       
        //Obtener el carácter de la posición 2
        caracterResultado = saludo.charAt(2);
        //Obtener el tamaño de la cadena
        valorResultado = saludo.length();
        //Obtener una subcadena
        cadenaResultado = saludo.substring(1, 3);
        //Mostrar en mayúsculas
        System.out.println(saludo.toUpperCase());
    }

}

Una cadena de caracteres que contenga valores numéricos, puede ser transformada a uno de los tipos de datos numéricos que sean compatibles y viceversa, utilizando el método ValueOf() precedido del nombre de la clase correspondiente al tipo de dato al que se desea convertir:

Ejemplo:
public class métodoValueOf {

    public static void main(String[] args) {
        int valorEntero;
        long valorLargo;
        float valorReal;
        double valorDoble;
        String cadenaConValor;
       
        valorEntero = Integer.valueOf("374");
        valorLargo = Long.valueOf("28462837");
        valorReal = Float.valueOf("233.83");
        valorDoble = Double.valueOf("873.9321");
        cadenaConValor = String.valueOf(2556);
    }

}

 

Contador de visitas