Los Remedios Informáticos

Clases y objetos

2010-01-18T13:02:00.001+01:00

Una clase es la descripción de un tipo de objetos. Por ejemplo, podemos definir la clase "Mesa" como la descripción de ese tipo de objetos. Todas las mesas tienen una serie de características en común que permiten definir las características de cada una de ellas. Podríamos utilizar como características que definen las mesas las siguientes: color, alto, ancho, largo, material, ubicación. Esas características se van a denominar atributos de la clase.

Clase Mesa:

color (cadena de caracteres)
alto (numérico entero)
ancho(numérico entero)
largo (numérico entero)
material (cadena de caracteres)
ubicación (cadena de caracteres)

De una determinada clase se pueden crear una serie de objetos, que serán instancias de esa clase. Objeto, instancia de clase o instancia son sinónimos. Siguiendo el ejemplo de la clase "Mesa", se pueden crear diversas mesas cada una de ellas con sus propios atributos, aunque pueden tener valores iguales en algunos casos. Cada objeto (mesa) creado tendrá un nombre exclusivo de lo identifica.

mesa01: "Blanco", 100, 120, 60, "Madera", "Aula1"
mesa02: "Verde", 100, 100, 50, "Plástico", "Aula1"
mesa03: "Blanco", 100, 120, 60, "Madera", "Aula2"
mesa04: "Rojo", 100, 120, 60, "Plástico", "Aula2"
mesa05: "Verde", 100, 100, 50, "Plástico", "Aula2

Cada clase tendrá definida una serie de operaciones que se pueden realizar sobre los objetos creados de esa clase. Esas operaciones se denomina métodos. Siempre habrá un método para crear los objetos de la clase que se denomina método constructor. En el ejemplo de la clase "Mesa" se tendrá un método para crear las mesas, y se pueden definir otros que permitan realizar una serie de operaciones, por ejemplo:

moverMesa: Permitiría cambiar la ubicación de una determinada mesa, por ejemplo, del Aula1 al Aula2.
PitarMesa: Permitiría cambiar el color de una determinada mesa, indicando el nuevo color que tendría.

Una aplicación en Java se compone de un conjunto de clases, de las que se crean objetos que interactúan entre sí. El programador puede instanciar (crear) objetos de las clases definidas por él o de las clases incluidas en el lenguaje.

Los nombres de las clases en Java empiezan, por convenio, en mayúscula, y los nombres de los objetos empiezan por minúscula.

Estructura básica de una clase en Java

/**

* Estructura básica de una clase en Java

*/

class NombreDeClase

{

    //Declaración de los atributos de la clase

    tipoDato atributo1;

    tipoDato atributo2;

    tipoDato atributo3;

    //Declaración de los métodos de la clase

    método1(argumentos)

    {

        //Declaración de las variables propias del método1

        //Sentencias de ejecución del método

    }

    método2(argumentos)

    {

        //Declaración de las variables propias del método2

        //Sentencias de ejecución del método

    }

}

Declaración y acceso a atributos de una clase

Los atributos son las características propias de cada clase. Cada objeto creado de una determinada clase tendrá una serie de valores asignados en dichos atributos, por tanto, permiten guardar información de cada objeto.

Ejemplo para la clase Alumno:

class Alumno

{

    String nombre;

    String apellidos;

    int añoDeNacimiento;

    int númeroPersonal;

    String grupo;

    String turnoHorario = "Mañana";

    //Declaración de los métodos

    ...

}

Como se puede observar en el atributo turnoHorario, se puede dar un valor inicial en la declaración de los atributos.

Desde otra parte del código se podrá acceder al valor que contiene un determinado atributo de un determinado objeto con el siguiente formato de sentencia:

nombreObjeto.atributo

Por ejemplo:

System.out.println(“El nombre es: “+alumno1.nombre);

Declaración de métodos

Los métodos de una clase definen el comportamiento y los valores de los atributos de un determinado objeto de esa clase.

El formato básico de declaración de los métodos es:

valorRetorno nombreMétodo(tipoDato argumento1, tipoDato argumento2, ...)
{
    //Declaración de variables propias del método
    //Sentencias con las acciones que debe realizar el método
    return valorQueDebeRetornar;
}

Los métodos pueden retornar un valor tras ejecutar las sentencias que contiene, o bien no retornar nada.

Si va a retornar un valor, se debe especificar el tipo de dato en la declaración delante del nombre. El valor que vaya a ser devuelto se indica con la sentencia return, por ejemplo, para retornar un String:

String nombreMétodo()

{

    //Sentencias del método

    return valorQueDebeRetornar;

}

Hay que tener en cuenta que la sentencia return termina la ejecución del método, por lo que debe escribirse en el lugar donde no deba ejecutarse posteriormente ninguna otra sentencia.

Siguiendo el ejemplo de la clase Alumno, se puede declarar un método dameGrupo que obtenga el grupo en el que se encuentra un determinado alumno:

String dameGrupo()

{

    return grupo;

}

El valor retornado puede ser un atributo de la misma clase o cualquier otro dato, por ejemplo, un valor booelano que indique si el alumno es mayor de edad:

boolean esMayorEdad()

{

    int añoActual = 2010;

    if(añoActual - añoDeNacimiento >= 18)

       return true;

    else

       return false;

}

Si el método no va a retornar ningún valor, se debe indicar con la palabra void delante del nombre, y no se emplea la sentencia return:

void nombreMétodo()

{

    //Sentencias del método

}

Por ejemplo, se puede declarar un método que únicamente muestre por pantalla el grupo al que pertenece un alumno, sin que retorne ningún otro valor.

void muestraGrupo()

{

    System.out.println("El alumno: " + nombre + " " + apellidos);

    System.out.println("Pertenece al grupo: " + grupo);

}

En la declaración del método se debe informar de los parámetros que puede aceptar el método, indicando el tipo de dato y un nombre para dicho parámetro que se utilizará como una variable dentro del mismo. Se escriben después del nombre del método, entre paréntesis y separados por comas.

void asignaValores(String nom, String ape, int añoNac, int num, String gru, String turno)

{

    //Asignación de valores a los atributos de la clase

    nombre = nom;

    apellidos = ape;

    añoDeNacimiento = añoNac;

    númeroPersonal = num;

    grupo = gru;

    turnoHorario = turno;    

    //Mostrar mensaje informativo

    System.out.println("Valores asignados correctamente");

}

Creación de objetos

Teniendo una clase declarada, se pueden crear tantos objetos como se quiera de esa misma clase. En el ejemplo que seguimos, una vez declarada la clase Alumno, podemos declarar una serie de alumnos cuyas características serán los atributos de la clase Alumno, y sobre los que se podrán realizar las acciones indicadas en los métodos declarados en la misma clase Alumno.

A los objetos creados se les hace referencia a través de una variable cuyo tipo de dato será el nombre de la clase. Se debe declarar una variable por cada objeto que se vaya a crear, o bien un array que contenga varios objetos de la misma clase.

nombreClase nombreObjeto;

Por ejemplo:

Alumno alumno1;

Alumno alumno2;

La acción de declarar la variable que haga referencia al objeto no implica que se haya creado el objeto, tan sólo se ha declarado el nombre que hará referencia al objeto. Por tanto, se debe realizar además la creación del objeto utilizando la sentencia new seguido del nombre de la clase.

nombreObjeto = new nombreClase();

Por ejemplo:

alumno1 = new Alumno();

Se puede hacer la declaración de la variable y la creación del objeto en una misma línea:

Alumno alumno1 = new Alumno();

Se puede crear un array de objetos de una clase siguiendo el siguiente ejemplo:

//Crear el array de objetos

Alumno alumnos[] = new Alumno[3];

//Crear cada objeto

alumnos[0] = new Alumno();

alumnos[1] = new Alumno();

alumnos[2] = new Alumno();

Llamada a los métodos

Para que se ejecuten las sentencias contenidas en un método, se debe hacer una llamada al mismo. La llamada a un método de una determinada clase se realiza indicando el nombre del objeto (ojo, no el nombre de la clase) sobre el que se desea aplicar la ejecución del método seguido del nombre del método separado por un punto.

Si el método tiene declarados parámetros, en la llamada se deben indicar entre paréntesis los valores reales que se van a asignar a cada parámetro.

Además, si el método retorna un valor se debe asignar el resultado del método a una variable del mismo tipo.

nombreObjeto.nombreMétodo();
nombreObjeto.nombreMétodo(valor1, valor2, ...);
valorRetornado = nombreObjeto.nombreMétodo();
valorRetornado = nombreObjeto.nombreMétodo(valor1, valor2, ...);

Las llamadas a los métodos de una clase se puede hacer desde métodos de la misma clase o desde métodos de otra clase, por ejemplo, desde la clase Main.

Algunos ejemplos de llamadas a métodos de la clase Alumno:

//Crear un nuevo alumno

Alumno alumno1 = new Alumno();

//Llamada a un método con parámetros

alumno1.asignaValores("Luis", "Pérez", 1979, 1, "1DAI", "Tarde");

//Llamada a un método sin parámetros

alumno1.muestraGrupo();

//Llamada a un método con retorno de valor

boolean mayorEdad = alumno1.esMayorEdad();

if(mayorEdad)

    System.out.println("Es mayor de edad");

//También se podría emplear directamente la llamada al método:

//if(alumno1.esMayorEdad())

//    System.out.println("Es mayor de edad");

Creación de nueva clase en NetBeans

Dentro de un mismo archivo ".java" se pueden crear varias clases, aunque suele ser más claro y cómodo crear un nuevo archivo para cada clase.

Desde NetBeans se puede crear fácilmente una nueva clase Java desde el menú contextual del paquete de fuentes, o desde el menú "Archivo > Archivo Nuevo", seleccionado la opción "Clase Java".

Descargar proyecto de ejemplo de la clase Alumno

Matrices en Java (Ejemplo 2)

2010-01-12T12:41:00.002+01:00

http://javiergarbedo.es/index.php/apuntes/31-arrays/127-ejemplos-de-matrices-en-java

Matrices en Java (Ejemplo 1)

2010-01-12T12:31:00.002+01:00

http://javiergarbedo.es/index.php/apuntes/31-arrays/127-ejemplos-de-matrices-en-java

Limitar el número de decimales a mostrar

2010-01-12T11:21:00.001+01:00

Cuando se muestra en pantalla un valor numérico real (double o float) aparece con un número elevado de decimales. En ocasiones es deseable que sólo se muestre un número concreto de decimales, por ejemplo, para mostrar un precio en Euros con dos decimales.

Para ello se puede utilizar el método format de la clase String siguiendo el siguiente ejemplo en el que se muestra en un campo de texto el valor de la variable num que es de tipo double:

        campoTexto.setText(String.format("%.2f", num));

En este ejemplo se mostrarán dos decimales. Si se desea obtener otro número de decimales, se deberá indicar dicha cantidad en el lugar del 2 que se encuentra dentro de la cadena de formato "%.2f".

En la API de Java se puede encontrar más información sobre la cadena de formato del método format.

Matrices

2010-01-11T11:31:00.002+01:00

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

Ejemplos de vectores en Java

2009-11-30T17:49:00.002+01:00

http://javiergarbedo.es/index.php/apuntes/31-arrays/126-ejemplos-de-vectores-en-java-

Parámetros para feeds RSS

2009-11-26T14:35:00.001+01:00

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

Vectores

2009-11-26T11:58:00.002+01:00

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

Arrays

2009-11-26T10:49:00.002+01:00

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

Depuración de programas con NetBeans

2009-11-23T12:19:00.001+01:00

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.

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"

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.

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"

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.

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"

Control de excepciones

2009-11-19T17:30:00.001+01:00

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:

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

Sentencia for

2009-11-09T12:05:00.001+01:00

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:

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.

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

2009-11-09T11:21:00.001+01:00

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:

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.

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 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.

Sentencia while

2009-10-29T11:48:00.001+01:00

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:

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

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.

Sentencia switch

2009-10-27T11:14:00.001+01:00

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:

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.

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

2009-10-27T09:12:00.002+01:00

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

2009-10-27T08:52:00.006+01:00

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.

Sentencia if y sentencia if-else

2009-10-26T12:16:00.001+01:00

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:

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

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:

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

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.

Obtener datos a través de formularios

2009-10-17T11:27:00.001+02:00

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.

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

    }

Mostrar datos a través de formularios

2009-10-15T12:16:00.001+02:00

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:

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.

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".

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.

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

    }

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:

    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.

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

Operaciones básicas con cadenas de caracteres

2009-10-07T18:14:00.001+02:00

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

    }

}

Operadores de asignación

2009-10-06T14:54:00.001+02:00

Permiten asignar valores a variables. El operador de asignación elemental es el igual (=) que asigna un valor o el resultado de una expresión a una variable, siguiendo el siguiente formato:

nombreVariable = valorAsignado;

Además del operador igual (=), se pueden emplear otros operadores de asignación, que a la vez que asignan un valor realizan un cálculo:

+= (le suma a la variable un valor y guarda el resultado en la misma variable).
-= (le resta a la variable un valor y guarda el resultado en la misma variable).
*= (multiplica la variable por un valor y guarda el resultado en la misma variable).
/= (divide la variable por un valor y guarda el resultado en la misma variable).
%= (obtiene el resto de dividir la variable por un valor y guarda el resultado en la misma variable).

Ejemplos:

cálculo = 5;

cálculo += 6; //Incrementa en 6 el valor de la variable cálculo

System.out.println(cálculo); //Muestra 11

cálculo *= 2; //Duplica el valor de cálculo

System.out.println(cálculo); //Muestra 22

Por tanto, una sentencia como a+=3 es lo mismo que a=a+3.

Otros operadores de asignación son el incremento y el decremento:

++ (incrementa en 1 el valor de una variable).
-- (decrementa en 1 el valor de una variable).

num1 = 3;

num2 = 7;

num1++; //Suma 1 a num1

System.out.println(num1); //Muestra 4

num2--; //resta 1 a num2

System.out.println(num2); //Muestra 6

por tanto, una sentencia como x++ es los mismo que x=x+1, y x-- es lo mismo que x=x-1.

Pero hay dos formas de utilizar el incremento y el decremento. Se puede usar por ejemplo x++ ó ++x. La diferencia estriba en el modo en el que se comporta la asignación.
Ejemplo:

int x=5, y=5, z;

z=x++; //z vale 5, x vale 6

       //porque primero se asigna el valor de x a z

       //después se incrementa x

z=++y; //z vale 6, y vale 6

       //porque primero se incrementa la variable y

       //después se asigna el valor de y a z

Constantes

2009-10-06T14:32:00.001+02:00

Son similares a las variables en cuanto que son datos a los que se hace referencia mediante un nombre y a los que se les asigna un valor. Pero a diferencia de las variables, a las constantes no se les modificar el valor asignado.

El formato de declaración de las constantes es prácticamente igual que el utilizado para las variables. La única diferencia es que se debe indicar el modificador final delante del tipo de dato que almacenará:

final tipoDato nombreConstante = valor;

Al igual que en la declaración de variables, el valor que se asigna en la declaración puede ser un valor literal, una variable o una expresión.
Ejemplo:

final double PI = 3.1415926536;

Por convenio, el nombre de las contantes se escribe en mayúsculas.

El beneficio de usar constantes es evitar la repetición de escribir un mismo valor en el programa y facilitar su modificación.

El empleo de las constantes a lo largo del programa es igual que el utilizado con las variables. Se indica su nombre dentro de cualquier expresión o como parámetro para métodos como println().

System.out.println("Perímetro = " + 2*PI*radio);

Variables

2009-10-06T11:35:00.001+02:00

Las variables identifican datos mediante un nombre simbólico, haciendo referencia a un espacio de memoria principal en los que se sitúan los datos, para que puedan ser utilizados por el procesador, y así poder hacer cualquier tipo de operación con ellos.

Los nombres utilizados para identificar a las variables deben cumplir una serie de condiciones:

No pueden empezar por un dígito numérico.
No pueden utilizarse espacios, y los únicos caracteres especiales válidos son el guión bajo (_) y el símbolo del dólar ($).
Son sensibles a las mayúsculas y minúsculas, es decir, las variables "suma" y "Suma" se consideran variables distintas.
No pueden utilizarse como nombres de variables las palabras reservadas de Java que son las siguientes:

Es costumbre empezar los nombres de las variables por una letra minúscula.
Cuando el nombre de una variable está formada por más de una palabra, se suele utilizar una letra mayúscula para distinguir el comienzo de las palabras. Por ejemplo: sumaTotal.
Es recomendable utilizar nombres que hagan referencia al contenido que va a almacenar para facilitar la compresión del código. Es mucho más claro utilizar el nombre "suma" que "s".

Ejemplos de nombres de variables válidos: Índice, ventas, Compras, saldoGeneral, importetotal, contador_líneas, $valor, num2.

Ejemplos de nombres de variables no válidos: 3valores, suma&total, super, edad media.

Antes de poder utilizar una variable, ésta debe ser declarada en el programa. La declaración de variables se debe realizar siguiendo el siguiente formato de sentencia:

tipoDato nombreVariable;

donde tipoDato es uno de los tipos de datos básicos o el nombre de una clase (byte, short, int, long, float, double, boolean, char, String, etc), y nombreVariable es el nombre que se desea asignar a la variable siguiendo las normas anteriores.

Es posible declarar más de una variable de un mismo tipo en la misma línea separando los nombres con comas:

tipoDato nombreVariable1, nombreVariable2, nombreVariable3;

Ejemplos de declaraciones de variables:

int num1, num2, suma;
char letraNIF;
String saludoInicial;
boolean mayorEdad;

Es posible asignar un valor inicial a las variables en el momento de declararlas. Para inicializar variables se debe seguir el siguiente formato de sentencia:

tipoDato nombreVariable = valorInicial;

donde valorInicial puede ser un valor literal, otra variable declarada anteriormente o una expresión combinando valores literales y variables con operadores. El valorInicial debe ser del mismo tipo de dato que la variable que se está declarando.

Ejemplos de declaraciones de variables con inicialización:

int num1 = 34;
int doble = num1 * 2;
String saludo = "Hola";
char letraA = 'A', letraB = 'B';

En el código del programa es posible asignar valores a las variables que previamente han sido declaradas. Al hacerlo, el valor que guardara la variable anteriormente se perdería. Se debe utilizar el siguiente formato:

nombreVariable = valor;

donde valor puede ser de nuevo un valor literal, una variable declarada anteriormente (puede ser la misma variable) o una expresión combinando valores literales y variables con operadores. El valor debe ser del mismo tipo de dato que la variable a la que se está asignado el nuevo valor.

package ejemplos;

public class AsignaciónVariables {

    public static void main(String[] args) {

        int a=5, b=0, c;

        b = a * 3; // Se cambia el valor de b a 15

        c = a;  // Se guarda en c el valor de a que es 5

        a = a + 6; // Se suma 6 al valor que tenía a. Ahora vale 11

        b = a - c; // b guarda 11 - 5 que es 6

        System.out.println("La variable a contiene: " + a);

        System.out.println("La variable b contiene: " + b);

        System.out.println("La variable c contiene: " + c);

        /* Se muestra lo siguiente:

               La variable a contiene: 11

               La variable b contiene: 6

               La variable c contiene: 5  

        */

    }

}

Las variables pueden ser utilizadas dentro del bloque de código en el que han sido declaradas, es decir, dentro de las llaves "{" y "}" que marcan el inicio y el fin de un bloque de código. Se denomina ámbito de la variable al bloque de código en el que se declara la variable.

package ejemplos;

public class ÁmbitoVariables {

    int variableGlobal;

    public static void main(String[] args) {

        int variableDelMain;

        //Aquí se pueden usar variableGlobal y variableDelMain

        //No se puede usar variableDeOtroMétodo

    }

    void otroMétodo() {

        int variableDeOtroMétodo;

        //Aquí se pueden usar variableGlobal y variableDeOtroMétodo

        //No se puede usar variableDelMain

    }

}

Para mostrar el contenido de una variable se puede utilizar System.out.print() y System.out.println() de la misma manera que se utiliza con los valores literales. Deben ser incluidas en los paréntesis únicamente con su nombre (sin comillas), pudiendo formar parte de expresiones.

        System.out.println(num1);

        System.out.println(num1 * 5 + num2);

        System.out.println("Resultado = " + total);

Operadores y expresiones de caracteres y cadenas de caracteres

2009-10-05T18:53:00.001+02:00

Los operadores que pueden ser utilizados con los caracteres son los mismos que los utilizables con los valores numéricos enteros. Esto es debido a que cada carácter es considerado como el valor numérico que le corresponde según los códigos de la tabla de caracteres Unicode.

Ejemplos:

(int)'A'

equivale al valor 65, ya que es el código asociado al carácter 'A'.

'A'+1

equivale al valor 66, ya que le suma 1 al código de la 'A'. No es necesario emplear la conversión de tipos al emplear operadores aritméticos.

'A'+'B'

equivale al valor 131, ya que se suma 65+66 que son los códigos de ambos caracteres.

(char)('A'+1)

equivale al carácter 'B', ya que se convierte a carácter el valor 66, correspondiendo al código de ese carácter.

(char)0x00E6

equivale al carácter 'æ', que es el que corresponde al código hexadecimal 00E6.

(char)230

equivale al carácter 'æ', que es el que corresponde al código 230 que equivale al valor hexadecimal 00E6 del caso anterior.

En el caso de las cadenas de caracteres, el único operador válido es el de "concatenación" representado por el signo más (+). El resultado que se obtiene con este operador es la unión de dos o más cadenas de caracteres formando una sola cadena. Hay que tener en cuenta que no añade ningún espacio entre las cadenas unidas, por lo que si se quiere separar con un espacio, se debe incluir en el final de la primera o al principio de la segunda cadena.

Empleado en combinación con valores numéricos puede realizar la conversión de números en cadenas de caracteres.

Ejemplo:

"Hola " + "mundo"

equivale a "Hola mundo".

"Nombre " + "Apellido1 " + "Apellido2"

equivale a "Nombre Apellido1 Apellido2".

"Hol" + 'a'

equivale a "Hola".

"Precio = " + 150 + "€"

equivale a "Precio = 150 €"

"" + 123

equivale a "123".

"precio" + 12 + 3

equivale a "precio123".

12 + 3 + "precio"

equivale a "15precio".

Operadores y expresiones relacionales y lógicos

2009-10-01T08:56:00.001+02:00

Los operadores relacionales y lógicos son aquellos que, al utilizarse en una expresión, el resultado es un valor lógico (true o false).

Los operadores relacionales permiten comparar dos valores numéricos. Son los siguientes:

> (mayor que)
>= (mayor o igual que)
< (menor que)
<= (menor o igual que)
== (igual que)
!= (distinto de)

Cada uno de estos operadores relacionales deben emplearse con dos valores numéricos a ambos lados, pudiendo ser dos valores literales o resultados de expresiones aritméticas. Ejemplos:

4 > 3 resulta true.
7 <= 2 resulta false.
5 + 2 == 4 + 3 resulta true.
4 * 3 != 12 resulta false.

Los operadores lógicos permiten unir valores o expresiones lógicas, obteniendo como resultado si es verdadera o falsa la expresión combinada. Son los siguientes:

&& (Y lógico - conjunción)
|| (O lógico - disyunción)
! (NO lógico)

Los operadores && y || deben utilizarse con dos valores o expresiones lógicas a ambos lados, mientras que el operador de negación ! sólo se aplica al valor o expresión lógica que tenga a su derecha.

El resultado que se obtiene utilizando estos operadores se obtiene de la siguiente tabla de verdad:

El operador Y resulta true sólo si ambos operandos son true:

true && true resulta true
true && false resulta false
false && true resulta false
false && false resulta false

El operador O resulta true si al menos uno de los operandos son true:

true || true resulta true
true || false resulta true
false || true resulta true
false || false resulta false

El operador NO resulta true si el operando es false:

!true resulta false.
!false resulta true.

Estos operadores también tiene un criterio de prioridad como en el caso de los operadores aritméticos:

Para cambiar la prioridad se pueden emplear paréntesis. Además, hay que tener en cuenta que estos operadores relaciones y lógicos tiene menos prioridad que los operadores aritméticos.

Operadores aritméticos (* / % + -)
Operadores relacionales (< <= > >= == !=)
Operadores lógicos (! && ||)

Ejemplos:

4 > 3 && 5 <= 5 resulta true, porque las dos expresiones son true.
4 > 3 && 5 != 5 resulta false, porque al menos una expresión es false.
4 > 3 || 5 != 5 resulta true, porque al menos una expresión es true.
4 > 3 && !(5 != 5) resulta true, porque las dos expresiones son true.
7==4+3 || 6<2 && 5>=8 resulta true porque se evalúa antes el operador && que el operador ||, según las prioridades de estos operadores:
true || false && false = true || false = true.
(7==4+3 || 6<2) && 5>=8 resulta false porque en este caso, con los paréntesis, se evalúa antes el operador || que el operador &&:
(true || false) && false = true && false = false.
7 > 4 && > 3 resulta ERRÓNEO, porque el operador && no tiene dos valores lógicos a sus lados, debería expresarse como: 7 > 4 && 7 > 3.

Operadores y expresiones aritméticas

2009-09-29T14:08:00.001+02:00

El lenguaje de programación Java incorpora una serie de operadores que permiten realizar cálculos y escribir expresiones que realicen una serie de operaciones sobre los datos.

+ (suma)
- (resta)
* (multiplicación)
/ (división entera o con decimales según operandos)
% (resto de la división)

Todos estos operadores aritméticos deben utilizarse con dos operandos, situados delante y detrás de los operadores, pudiéndose encadenar las operaciones. Se pueden incluir espacios para aclarar más el código.

Los datos usados como operandos deben ser de alguno de los tipos de datos numéricos (byte, short, int, long, float o double). Ejemplos:

4 + 3
8 - 5 + 2
6 * 2 / 3
8.5 - 3 + 4.3

El resultado de la división tendrá decimales o no según el tipo de operandos que se utilice. Si los dos son enteros, el resultado no tendrá decimales, pero si al menos uno de los operandos es de tipo numérico real (float o double) el resultado será de ese tipo. Ejemplos:

8 / 2 resulta 4
7 / 2 resulta 3
7.0 / 2 resulta 3.5
7 / 2.0 resulta 3.5
7.4 / 2 resulta 3.7
8 / 2.5 resulta 3.2
8.5 / 2.5 resulta 3.4

Es posible modificar el tipo de dato de cualquier operando indicando delante el nuevo tipo de dato entre paréntesis. Así se hace una conversión de tipo:

(double)7 / 2 resulta 3.5
7 / (float)2 resulta 3.5

El operador resto se debe utilizar con tipos de datos numéricos enteros. El resultado será el resto de la división entre los dos operandos. Ejemplos:

7 % 2 resulta 1
8 % 3 resulta 2

El resultado de cualquier operación aritmética será del tipo de dato más grande que se utilice en los operandos. Por ejemplo, si se hace una operación entre dos números enteros (int) el resultado será del mismo tipo, pero si se hace entre un int y un long es resultado es de tipo long. Ejemplos:

2147483647 * 2 resulta un dato incorrecto, en concreto -2, porque se están multiplicando dos int y el resultado sobrepasa el límite de los enteros.
2147483647L * 2 resulta 4294967294 porque el primer operando es de tipo long (se ha indicado L al final).

Al igual que en las expresiones matemáticas habituales, los operadores aritméticos y en general todos los operadores, tienen un orden de precedencia:

Multiplicación (*), División (/) y Resto (%)
Suma (+) y Resta (-)

Dentro del mismo orden de precedencia, las operaciones se realizarán en orden de izquierda a derecha. Si es necesario cambiar el orden de precedencia, se deben utilizar paréntesis de la forma habitual. Ejemplos:

4 + 3 * 2 resulta 10 (4+6)
(4 + 3) * 2 resulta 14 (7*2)
4 / 2 * 3 resulta 6

Utilizando la sentencia System.out.println(); se muestra, por salida estándar, el resultado de cualquier expresión aritmética o de cualquier otro tipo. Ejemplos:

System.out.println((4 + 3) * 2);
Muestra 14
System.out.println("(4 + 3) * 2");
Muestra (4 + 3) * 2 ya que lo considera una cadena de caracteres

Los caracteres pueden ser utilizados para realizar cálculos aritméticos. En caso de que aparezca algún carácter en una expresión aritmética, se toma el valor numérico que le corresponde a cada carácter en la tabla de codificación Unicode. Ejemplos:

'A' + 1 resulta 66, ya que el carácter 'A' tiene el código 65.
(char)('A' + 1) resulta 'B' ya que se ha hecho una conversión de tipos del resultado, convirtiendo el valor 66 a su correspondiente carácter.

Inserción de comentarios en el código fuente

2009-09-28T12:53:00.001+02:00

En el código fuente de un programa Java es posible escribir texto de forma libre, es decir, sin tener que seguir las normas del lenguaje Java, con el fin de indicar comentarios sobre las sentencias del programa. El texto escrito como comentario no es tenido en cuenta por el compilador.

Es recomendable escribir este tipo de comentarios ya que facilita la compresión del programa cuando es leído por otra persona o por el mismo creador, especialmente cuando ha pasado algún tiempo desde que fue escrito el código.

Para escribir un comentario, éste puede ir precedido por dos barras //, o bien, encerrado entre los caracteres /* y */. Si se utilizan las dos barras, el comentario sólo se puede escribir en una línea, a partir de esos caracteres. En caso de que el comentario vaya a ocupar más de una línea se debe utilizar el segundo método: /* comentario */.

Ejemplo:

// Esta línea es un comentario

System.out.println("Saludo"); // Comentario detrás

// Esta es la forma de comentar más de una línea utilizando

// las dos barras. Se incluyen dos barras al comienzo 

// de cada línea

/* Esta segunda forma es mucho más cómoda para comentar

un número elevado de líneas ya que sólo requiere modificar

el comienzo y el final. */

Java incluye una utilidad llamada javadoc, que permite generar de forma automática alguna documentación de las aplicaciones. Para darle determinados datos a esa utilidad, se utiliza otro tipo de comentarios que comienzan con /** y terminan con */. Por ejemplo:

    /**

     * @param args the command line arguments

     */

Valores literales

2009-09-28T11:23:00.001+02:00

Un valor literal es la representación de un valor fijo en el código fuente de un programa.

Los valores correspondientes a los tipos de datos numéricos enteros (byte, short, int y long) se pueden expresar usando el sistema numérico decimal, octal o hexadecimal. Los números en sistema decimal se expresan de la manera habitual, simplemente escribiendo su valor con los dígitos numéricos, por ejemplo, 284. No se pueden emplear separadores de millares, por lo que para indicar el valor 1.000.000 (un millón) se debe escribir como 1000000. Para representar valores negativos se añade el carácter "-" (guión) delante del número, como es habitual es la escritura normal, por ejemplo, -387.

Para representar un valor numérico entero en sistema octal, debe ir precedido del carácter 0 (cero), por ejemplo, el valor 284 se representa en octal como 0434. Así mismo, para representar un valor en el sistema hexadecimal, se debe emplear el prefijo 0x, por lo que el valor 284 se representa en hexadecimal como 0x11C.

Por defecto, los valores literales numéricos enteros se almacenan en memoria con el formato del tipo de dato "int". Si se desea almacenar como "long", con el fin de poder obtener resultados con valores muy altos en los cálculos, se debe emplear el sufijo L en mayúscula o minúscula (sería recomendable utilizar la L mayúscula por el parecido de la letra minúscula con el valor 1). Por ejemplo, el valor 284L correspondería al valor entero 284 utilizando 64 bits (tipo long) para almacenarlo en memoria.

Para representar valores literales de los tipos de datos numéricos reales (float y double) se puede emplear el sistema decimal o la notación científica. En el sistema decimal se expresan los números con parte decimal de la forma usual, utilizando el punto como separador de la parte entera y decimal. En este caso tampoco se puede emplear los separadores de millares. Así, por ejemplo, el valor 21.843,83 se debe expresar como 21843.83 en el código fuente.

Los números reales expresados en notación científica deben emplear la letra "E" o "e" para separar la parte correspondiente al exponente. El valor 7,433·10⁶ se debe expresar como 7.433e6 en el código fuente. Si el exponente es negativo se escribe el guión detrás de la letra E, por ejemplo, 7,433·10^-6 se expresa como 7.433e-6, y si el valor es negativo se indica el guión al principio, por ejemplo, -7,433·10⁶ se expresa como -7.433e6.

Por defecto, los valores literales numéricos reales se almacenan en memoria con el formato del tipo de dato "double". Si se desea almacenar como "float", con el fin de emplear menos espacio de memoria y necesitar menos precisión en los resultados de los cálculos, se debe emplear el sufijo F en mayúscula o minúscula. Por ejemplo, el valor 21843.83F correspondería al valor entero 21843.83 utilizando 32 bits (tipo float) para almacenarlo en memoria, en vez de 64 bits.

Los valores literales de los tipos char (carácter) y String (cadena de caracteres), pueden contener cualquier carácter Unicode. Los valores de tipo char se debe expresar encerrados entre comillas simples (en los teclados españoles habituales se encuentra junto a la tecla del cero), por ejemplo, la letra A se debe expresar como 'A'. Por otro lado, las cadenas de caracteres (tipo String) se expresan entre comillas dobles (en la tecla del 2), por ejemplo, el texto Saludos a todos, se debe escribir como "Saludos a todos".

En caso de que se necesite escribir un carácter de la tabla de caracteres Unicode que no se encuentre en el teclado, se puede hacer indicando el código hexadecimal correspondiente a dicho carácter precedido del modificador \u (utilizando la barra invertida situada en la tecla junto al 1). En todo caso se debe encerrar entre comillas simples o dobles según se vaya a tratar como carácter o dentro de una cadena de caracteres. Por ejemplo, para escribir la letra griega beta (ß) se puede emplear '\u00DF', o para escribir la palabra España es posible utilizar "Espa\u00F1a".

El lenguaje de programación Java también soporta un pequeño conjunto de caracteres especiales que se pueden utilizar en los valores literales char y String:

\b (retroceso), \t (tabulador), \n (nueva línea), \f (salto de página), \r (retorno de carro), \" (comilla doble), \' (comilla simple), \\ (barra invertida).

Por ejemplo, la cadena de caracteres "La palabra "hola" es un saludo" se tiene que escribir en el código fuente como: "La palabra \"hola\" es un saludo", para que no confunda las comillas dobles de inicio y fin de la cadena de caracteres.
El carácter especial '\n' permite introducir un salto de línea dentro de una cadena de caracteres. Por ejemplo, "Primera línea\nSegunda línea" mostraría ese texto separado en dos líneas.

Los valores literales para el tipo de dato boolean sólo pueden ser true o false, que corresponden a los valores Verdadero y Falso. Hay que observar que se deben indicar sin comillas de ningún tipo, ya que no son cadenas de caracteres.

En un programa, es posible mostrar cualquiera de estos valores literales a través de la salida estándar (terminal, ventana de salida, etc) utilizando la siguiente sentencia:

System.out.println(valorLiteral);

o bien:

System.out.print(valorLiteral);

Donde valorLiteral debe ser el valor que se desea mostrar manteniendo las normas comentadas anteriormente.

Ambas sentencias se diferencian en que la primera (println) tras mostrar el valor realiza un salto de línea (como una pulsación de Intro), mientras que la segunda (print) no introduce el salto de línea por lo que si se muestra otro dato con otra sentencia print o println se mostrará justo a continuación.

Algunos ejemplos:

//Mostrar un valor numérico entero

System.out.print("Número entero: ");

System.out.println(284);

//Mostrar un valor numérico real

System.out.print("Número real: ");

System.out.println(21843.83);

//Mostrar un carácter

System.out.print("Carácter: ");

System.out.println('A');

//Mostrar una cadena de caracteres

System.out.print("Cadena de caracteres: ");

System.out.println("Saludos a todos");

//Mostrar un valor lógico

System.out.print("Valor lógico: ");

System.out.println(true);

Tipos de datos básicos

2009-09-28T09:50:00.001+02:00

El lenguaje de programación Java permite la utilización de los siguientes tipos de datos básicos:

Números enteros: Representan a los números enteros (sin parte decimal) con signo (pueden ser positivos o negativos). Se dispone de varios tipos de datos, ocupando cada uno de ellos un espacio distinto en memoria. Cuanta más capacidad de almacenamiento, más grande es el rango de valores permitidos, aunque ocupará más espacio de memoria principal. Se dispone de los siguientes tipos:

byte: Ocupan 8 bits (1 byte), permitiendo almacenar valores entre -128 y 127.
short: Ocupan 16 bits (2 bytes), permitiendo almacenar valores entre -32.768 y 32.767.
int: Ocupan 32 bits (4 bytes), permitiendo almacenar valores entre -2.147.483.648 y 2.147.483.647. Es el tipo de datos por defecto para los valores numéricos enteros. Este tipo de datos es lo suficientemente grande para almacenar los valores numéricos que vayan a usar tus programas. Sólo se suelen usar los tipos anteriores si se pueden producir problemas con el espacio de memoria.
long: Ocupan 64 bits (8 bytes), permitiendo almacenar valores entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807.

Números reales: Representan a los números reales con parte decimal y signo positivo o negativo. Hay dos tipos de datos numéricos reales que permiten obtener mayor o menor precisión. Utilizan un método para almacenar los datos que puede ocasionar que el valor original varíe levemente del valor almacenado realmente. Cuanta más precisión se utilice, habrá menor variación.

float: Ocupan 32 bits (4 bytes). Se le denomina de simple precisión.
double: Ocupan 64 bits (8 bytes). Se le denomina de doble precisión. Es el tipo de datos por defecto para los valores numéricos reales.

Valores lógicos: Representan dos únicos posibles valores: verdadero y falso.

boolean: Ocupan 1 bit, pudiendo almacenar los valores true (verdadero) y false (falso).

Caracteres: Representan las letras, dígitos numéricos y símbolos contenidos en la tabla de caracteres Unicode.

char: Ocupan 16 bits (2 bytes). Permite representar un único carácter, por ejemplo la letra 'A'.
String: Realmente no es un tipo de dato básico de Java, pero por su interés se incluye aquí. Permite representar un conjunto de caracteres, por ejemplo: "Saludos para todos".

Proyectos y clases Java con NetBeans

2009-09-27T19:59:00.001+02:00

Las aplicaciones Java creadas con NetBeans se organizan como proyectos. Cada proyecto además está dividido en:

Paquetes de fuentes
Paquetes de prueba
Bibliotecas
Bibliotecas de pruebas

El código que se escriba, y las ventanas que se diseñen para la aplicación, se almacenarán en la sección "Paquetes de fuentes". En esa sección se crea por defecto un paquete con el mismo nombre que el proyecto.

Dentro de los paquetes de fuentes se pueden crear distintos tipos de archivos. Por ejemplo, se pueden crear Clases Java, que contendrán únicamente código en Java para realizar una determinada tarea. Se pueden crear también Formularios que serán las típicas ventanas de las aplicaciones con entornos gráficos. Los formularios para aplicaciones de escritorio se denominan Formularios JFrame.

Para crear un nuevo archivo dentro de un paquete de fuentes se puede utilizar el menú "Archivo > Archivo nuevo ..." o bien usar el menú contextual del paquete de fuentes.

Un mismo proyecto puede tener varias clases e incluso varios paquetes de fuentes como se puede ver en el siguiente ejemplo:

Pero siempre al menos una de la clases debe ser la clase principal, es decir, aquella por lo que debe empezar la ejecución de la aplicación que se está creando. La clases candidatas a ser clase principal se diferencia visualmente de las demás porque en su icono aparece un triángulo verde (en el ejemplo anterior se puede ver sobre la clase Anagrams.java). Pueden ser clases principales aquellas que contengan un método llamado "main" dentro de su código fuente.

    public static void main(String[] args)

Si se deseara establecer otra clase como principal, se puede realizar esa acción desde las propiedades del proyecto. A dichas propiedades se puede acceder desde el menú "Archivo > Project Properties" o desde el menú contextual abierto sobre el icono del proyecto. En la ventana de diálogo que aparece se debe elegir en la parte izquierda la sección "Ejecutar", y ahí aparece un campo de texto donde se puede indicar cuál será la clase principal.

Aunque un proyecto tenga varias clases definidas, en algunas ocasiones es interesante ejecutar una sola clase de manera individual para hacer algún tipo de prueba. Para ello se dispone de la opción "Ejecutar archivo" dentro del menú contextual que se puede abrir sobre el icono o el nombre de la clase que se desea ejecutar. La clase que se desee ejecutar debe tener un método "main".

Al crear un nuevo proyecto del tipo "Aplicación Java" con NetBeans, automáticamente se crea parte del código fuente del programa en una nueva "Clase Java", con la estructura básica para comenzar a escribir código en el mismo:

En caso de que al paquete de fuentes se le añada un "Formulario JFrame", es decir, una ventana, lo que se muestra es el diseño gráfico del formulario con la posibilidad de ir añadiendo componentes al formulario arrastrando los elementos deseados desde la Paleta.

Para ver el código fuente correspondiente a un formulario, se debe hacer clic en la parte superior donde se puede seleccionar entre "Fuente" y "Diseño".

Al seleccionar "Fuente" aparece en pantalla la estructura básica del código fuente del formulario.

La sentencia initComponentes(); que aparece en el código, es la que crea la ventana que se ha elaborado desde la vista "Diseño". Por tanto, cualquier modificación de la ventana o de sus elementos que se desee realizar desde código, deberá realizarse escribiendo las sentencias oportunas a continuación de esa instrucción.

En el código anterior, que ha sido generado automáticamente al crear un formulario, se puede observar que hay áreas sombreadas. Esas zonas no pueden ser modificadas por el programador desde el editor de código fuente, ya que están relacionadas con los elementos que han sido incluidos de forma gráfica en el formulario utlizando la vista "Diseño".

En NetBeans es posible tener abiertos simultáneamente varios proyectos, pero sólo uno de ellos será el "Proyecto principal". El proyecto que se encuentre seleccionado como proyecto principal será el que se ejecute cuando se lance la orden de Ejecutar desde NetBeans. El proyecto principal se diferencia visualmente de los demás porque aparece resaltado su nombre en negrita.

Es posible seleccionar otro proyecto como el principal desde el menú contextual abierto sobre el nombre del proyecto, o bien, desde el menú "Ejecutar > Establecer como proyecto principal".

En el menú contextual, y desde el menú "Archivo" se pueden "Cerrar" los proyectos que se encuentran abiertos. No confundir con "Eliminar", ya que esta operación puede borrar toda la información del proyecto almacenada en el disco duro.

Ejemplo de edición, compilación y ejecución por línea de comandos

2009-09-25T07:59:00.001+02:00

Se va a mostrar a continuación cómo se puede crear el programa "Hola mundo" editándolo con un editor de textos, compilándolo y ejecutándolo desde la línea de comandos.

En primer lugar se escribe el código en un editor de textos sencillo, como el bloc de notas de Windows. El código del programa es el siguiente:

public class HolaMundo
{

public static void main(String args[])
{

System.out.println("Hola Mundo!");

}

}

Tras abrir el bloc de notas se copia y pega el código anterior.

El archivo se debe guardar asignándole el mismo nombre, exactamente, que el indicado tras la palabra "class". En este caso es "HolaMundo". Además, el archivo debe tener la extensión ".java", por lo que en la ventana de diálogo de Guardar se debe seleccionar el tipo "Todos los archivos" (ya que no es un archivo de texto txt), y en el cuadro de texto del nombre se debe indicar: "HolaMundo.java", comprobando que se respetan las mayúsculas y minúsculas.

Si el archivo se guarda en la carpeta "Mis documentos", al abrir el "Símbolo del sistema" se debe acceder a dicha carpeta. Por defecto se abre en la carpeta principal del usuario (C:\Documents and settings\usuario). Para ir a la carpeta "Mis documentos" se debe ejecutar el comando: "cd Mis documentos" (Si el archivo que contiene el código fuente se ha guardado en otra carpeta se debe acceder a dicha carpeta utilizando el comando CD seguido de la ruta completa hasta dicha carpeta).

Una vez que estemos situados en la carpeta donde se ha almacenado el archivo java, se debe llamar al compilador Java indicándole el nombre del archivo que contiene el código fuente a compilar. En este caso se debe ejecutar: "javac HolaMundo.java".

Si el código se ha escrito correctamente, no debe aparecer ningún mensaje en pantalla. En caso de que haya algún error en el código fuente, se mostrará el error encontrado tras llamar al compilador.

Para comprobar que se ha generado el archivo compilado "HolaMundo.class" se puede utilizar el comando "dir".

Ya sólo queda ejecutar el programa compilador, utilizando el comando: "java HolaMundo". Si todo ha ido bien, aparecerá el mensaje que se había escrito en la sentencia "System.out.println", que en este caso era "Hola Mundo!".

Instalación del compilador de Java (Java Development Kit - JDK)

2009-09-22T11:37:00.001+02:00

Desde el sitio web de java (java.sun.com) debe realizarse la descarga del compilador de Java (Java Development Kit - JDK), desde la sección descargas (Downloads).

Aparecen varias descargas posibles, por lo que hay que localizar aquella que indique algo como Java SE Development Kit (JDK).

Se debe seleccionar la plataforma (sistema operativo) en el que se desea hacer la instalación (por ejemplo, Windows), y hay que marcar la casilla "I agree to the Java SE Development Kit License Agreement" si estamos de acuerdo con la licencia de Java.

Es posible que aparezca una nueva página con una serie de posible archivos que pueden descargarse. En ese caso deberemos elegir el que haga referencia al Java SE Development Kit. Haciendo clic en el nombre del archivo (en este ejemplo es: jdk-6u16-windows-i586.exe) comenzará directamente la descarga del programa. En ese momento tenemos la opción de abrirlo directamente o guardarlo para abrirlo posteriormente teniendo así la posibilidad de dejarlo guardado para otro momento.

Una vez finalizada la descarga comienza la instalación.

Hacer clic en "Continue".

Para continuar con la instalación, se debe aceptar la licencia pulsando el botón "Accept >".

Es posible especificar exactamente qué programas o características se desean instalar. SI no se desea una instalación muy personalizada se puede dejar todo por defecto y hacer clic en "Next >" para continuar.
Conviene observar la carpeta en la que se va a realizar la instalación del compilador. En este caso se puede ver que es: "C:\Archivos de programa\Java\jdk1.6.0_16\". Según la versión descargada, variará dicha carpeta.

Al finalizar el proceso hay que hacer clic en el botón "Finish".

Ahora es el momento de comprobar si se ha realizado bien la instalación y hacer algún último ajuste.
Debemos abrir el "Símbolo del sistema" que se puede encontrar en "Inicio > Todos los programas > Accesorios > Símbolo del sistema".
La llamada al compilador de Java desde el Símbolo del sistema se hace con el comando javac.
Se puede comprobar que al escribir directamente ese comando, realmente no funciona, ya que se debería especificar en qué carpeta se encuentra instalado el compilador.

En cambio, al llamar al comando "javac" especificando delante la ruta completa donde se ha realizado la instalación, debería funcionar correctamente. Para comprobar cuál es la carpeta donde se ha hecho la instalación se puede abrir el icono "Mi PC" y buscar en la unidad C: dentro de la carpeta "Archivos de programa" y "Java". En ella aparecerá una carpeta con el nombre "jdk" seguido de los números correspondientes a la versión instalada. Dentro de esa carpeta existe otra llamada "bin" que al abrirla se debe encontrar el archivo ejecutable "javac". En la barra de direcciones se puede observar la ruta seguida hasta encontrar el compilador. En este ejemplo es "C:\Archivos de programa\Java\jdk1.6.0_16\bin".

En este caso, la llamada se hace con el comando "C:\Archivos de programa\Java\jdk1.6.0_16\bin\javac", dejando incluso las comillas para que los espacios los considere como parte de la llamada al compilador. Recuerda que dependiendo de la versión del JDK descargada, la carpeta de instalación variará.

Lo ideal para usar con comodidad el compilador es no tener que escribir continuamente la ruta completa. Para ello debemos incluir dicha ruta en la variable PATH del sistema. Eso se hace siguiendo los siguientes pasos:

Entrar en la "Propiedades" de "Mi PC", por ejemplo, haciendo clic con el botón derecho sobre el icono de "Mi PC" y seleccionar "Propiedades" en el menú contextual abierto.

Acceder a la pestaña "Opciones avanzadas" y hacer clic en el botón "Variables de entorno".

En la sección "Variables del sistema" seleccionar la variable "Path" y hacer clic en el botón "Modificar".

En el campo de texto "Valor de variable" se debe escribir al final del contenido que hubiera la ruta al compilador que hemos comentado anteriormente. Recuerda que se debe escribir al final de lo que hubiera utilizando como separador el signo punto y coma ";". Por ejemplo, en este caso se ha añadido al final ";C:\Archivos de programa\Java\jdk1.6.0_16\bin". No utilices espacios en la separación, sólo el punto y coma.
Haz clic en "Aceptar" para finalizar.

Ahora debería funcionar correctamente la llamada al compilador desde el "Símbolo del sistema" sólo con llamar al comando "javac".

Primer programa en Java con NetBeans

2009-09-17T21:11:00.001+02:00

Para desarrollar un programa en Java con netBeans se debe crear un proyecto, para lo cual, tras abrir el programa se debe elegir la opción Proyecto Nuevo del menú Archivo, o bien hacer clic en el botón de la barra de herramientas similar al que aparece en dicho menú.

En función del tipo de distribución de NetBeans descargado e instalado, aparece un listado de tipos de Proyectos que se pueden crear, los cuales aparecen agrupados en Categorías.

Para crear un programa básico en Java, para ser utilizado bajo el Símbolo del sistema o el Terminal, hay que seleccionar la Categoría Java y el tipo de Proyecto debe ser Aplicación Java.

Tras hacer clic en el botón Siguiente comenzará el asistente que permite crear un proyecto del tipo seleccionado.

En primer lugar se especifica el nombre del proyecto a crear dentro del cuadro de texto Nombre del proyecto. Es lo único que debe modificarse en esta ventana de diálogo. Para este ejemplo se ha indicado el nombre HolaMundo. En este nombre se pueden utilizar espacios aunque posteriormente los archivos que se crean serán eliminados o sustituidos por el guión bajo.

Tan sólo con eso comenzará el proceso de creación del nuevo proyecto tras hacer clic en el botón Terminar. El progreso de la creación del proyecto puede observarse en la barra que aparece en la parte inferior, el cual, una vez finalizado, dará paso al entorno de desarrollo donde se deberá escribir el código del programa.

El código fuente de la aplicación debe escribirse en el editor de textos de la parte derecha donde inicialmente aparece la siguiente plantilla sobre la que se puede escribir el resto del código:

/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */

package holamundo;

/**

 *

 * @author Usuario

 */

public class Main {

    /**

     * @param args the command line arguments

     */

    public static void main(String[] args) {

        // TODO code application logic here

        System.out.println("Hola mundo");

    }

}

Las instrucciones que vayan a formar parte de la aplicación deberán escribirse sustituyendo la línea comentada en la que aparece:

// TODO code application logic here

En el primer programa que se va a desarrollar únicamente debe mostrarse en pantalla el típico mensaje "Hola mundo". Por lo que se escribirá en ese lugar la orden:

System.out.println("Hola mundo");

Ahora es el momento de compilar el código escrito, para lo que se dispone en el menú Ejecutar de las opciones Build Main Project que realiza el proceso de compilación, o de Clean and Build Main Project que además de compilar realiza previamente una limpieza de cualquier compilación anterior. Por tanto, optaremos por una de estas soluciones.

Estas herramientas pueden ser utilizadas desde los botones de la barra de herramientas donde se muestra el mismo icono que el mostrado en el menú Ejecutar.

El resultado de la compilación se puede ver en la parte inferior de la ventana. En caso de que la compilación haya sido satisfactorio aparece en la barra de estado, durante un tiempo, el mensaje "Ha terminado la generación de ...".

Pero si hay errores en el código fuente éstos se mostrarán en la ventana de Salida que se abre en la parte inferior derecha. Al detectarse los errores se abre automáticamente esa pestaña, pero se puede especificar que se muestre desde el menú Ventana > Salida > Salida. La pequeña X que aparece en el título de la pestaña Salida permite cerrarla.

Para realizar la ejecución del programa hay que seleccionar la opción Ejecutar > Run Main Project, o realizar eso mismo desde el botón de la barra de herramientas en forma de triángulo verde (como un botón Play de un reproductor).

El resultado de la ejecución aparece en la ventana Salida.

Estructura de archivos en proyectos NetBeans

2009-09-15T20:36:00.001+02:00

En la parte izquierda de la ventana de NetBeans aparecen tres pestañas que permiten mostrar distinta información en ese panel: Proyectos, Archivos y Prestaciones.

Al seleccionar la pestaña Archivos, se muestra un árbol con las carpetas y archivos que se crean automáticamente al generar un proyecto.

Las carpetas más interesantes son las siguientes:

La carpeta "build" contiene las clases compiladas (.class).
En la carpeta "dist" se crea un archivo comprimido con la extensión ".jar" que contiene todos los archivos necesarios para distribuir la aplicación generada y que pueda ser ejecutada.
La carpeta "src" almacena los archivos con el código fuente (.java) que hemos escrito o que forman parte de la aplicación.

Todas esas carpetas y archivos pueden encontrarse con la misma estructura dentro del disco duro en la carpeta donde se haya creado el proyecto.

Editores, compiladores y entornos de desarrollo para Java

2009-09-15T20:01:00.001+02:00

El proceso habitual para crear una aplicación informática ese editar el código fuente (escribir el programa en el lenguaje de programación elegido), compilarlo (es decir, traducirlo al lenguaje máquina) y ejecutar la aplicación. Pero ahí no termina el proceso, porque lo más habitual es que haya se detecten errores o se necesiten mejoras del programa que requieran que se vuelva a editar, compilar y ejecutar para ver los nuevos resultados, lo cual se puede repetir numerosas veces. Esos errores se pueden detectar en el momento de la compilación, o durante la ejecución.

Para editar un programa en Java se puede utilizar desde un sencillo editor de textos como el Bloc de notas, hasta un entorno de desarrollo más completo como NetBeans, Eclipse o Jcreator. No se puede utilizar un editor de textos que aplique formato al texto como lo hace Word u OpenOffice Writer.

Para escribir el código fuente de un programa Java desde un editor de textos, se debe escribir el código del programa y hay que guardarlo con la extensión ".java". Los entornos de desarrollo harán esto automáticamente.

Hay editores de textos con la sencillez del Bloc de notas pero que añaden otras mejoras, como el coloreo del código para facilitar su análisis, creación de macros que automaticen algunas tareas habituales, etc. Algunos ejemplos de editores gratuitos para son Notepad++ o Scite.

Para compilar un programa Java se necesita tener instalado correctamente en el ordenador el compilador Java de Sun que se puede descargar libremente desde la página Java de Sun (java.sun.com), con el nombre JDK (Java Development Kit). Existe una versión del JDK para cada perfil de Java (Java SE, EE, ME, FX, etc).

Descarga del Java SE Development Kit 6 update 16

Una vez instalado el compilador se puede compilar un programa Java desde el Símbolo del sistema o el Terminal con la orden:

rutaCompilador\javac nombreArchivo.java

donde rutaCompilador es la ruta completa a la carpeta donde se haya instalado el compilador, y nombreArchivo es el nombre del archivo que contiene el código fuente.

Al realizar la compilación del código fuente Java, y si no se han detectado errores, se crea un archivo con el mismo nombre que el archivo que contiene el código, pero con la extensión ".class". Ese es el archivo que puede ser ejecutado. Para ello, desde el Símbolo del sistema o el Terminal se debe escribir la orden:

java nombreArchivoJava

Hay que observar que en este caso no se debe escribir la extensión del archivo.

Para poder ejecutar un programa Java no es necesario disponer del archivos o los archivos que contienen el código fuente, tan sólo en necesario tener los archivos compilados. Por ello, si deseamos distribuir una aplicación que hemos creado, y no queremos que pueda ser modificado por otras personas, sólo se deben hacer públicos los archivos compilados, junto con los recursos necesarios (imágenes, sonidos, etc).

Los entornos de desarrollo integrado (IDE) son aplicaciones que permiten realizar todo el proceso de desarrollo de aplicaciones desde un mismo programa. Es decir, con uno de estos programas podemos editar, compilar, ejecutar programas en Java o en muchos otros lenguajes de programación, y todo dentro de un entorno gráfico. Además cuentan con otras herramientas de ayuda para la programación como la depuración (para la búsqueda de errores), coloreado del código fuente, plantillas predefinidas con la estructura básica de aplicaciones, etc.

Para Java, los principales entornos de desarrollo son NetBeans (que cuenta con el apoyo de Sun), Eclipse y JCreator. Los dos primeros son gratuitos, con soporte de idiomas y multiplataforma (Windows, Linux, MacOS).

Descarga de NetBeans IDE

Lenguaje de programación Java

2009-09-15T20:00:00.003+02:00

Java es un lenguaje de programación desarrollado por Sun Microsystems a principios de los años 90. Toma mucha sintaxis de los lenguajes de programación C y C++, aunque se han eliminándose algunas herramientas de bajo nivel que inducían a errores en el desarrollo de las aplicaciones.

En 2007 se liberó la mayor parte de la tecnología Java bajo licencia GNU GPL, de tal forma que prácticamente todo el lenguaje Java de Sun es ahora software libre.

Existen varias teorías sobre el origen del nombre Java aunque la más aceptada es la del nombre de un tipo de café que se servía en una cafetería que frecuentaban sus creadores, de ahí que el icono de Java sea una taza de café.

Java es un lenguaje multiplataforma, por lo que un mismo programa escrito en Java puede ser ejecutado en distintos tipos de ordenadores o plataformas, por ejemplo, Windows, Unix, Macintosh, etc.

Para poder ejecutar un programa Java es necesario tener instalado en el equipo una máquina virtual Java. Se trata de un programa que traduce las instrucciones compiladas del programa Java al lenguaje máquina que corresponda, según la plataforma bajo la que se ejecute el programa. Sun proporciona de forma gratuita una máquina virtual Java con el nombre Java Runtime Environment (JRE) que puede descargarse desde la web de Java. buscando la versión correspondiente al sistema operativo sobre el que se desea ejecutar el programa.

Con Java se pueden desarrollar aplicaciones para diversos entornos de funcionamiento:

Sin entorno gráfico, para el terminal.
Con entorno gráfico de Windows, Linux o MacOS.
Aplicaciones para páginas web.
Aplicaciones para dispositivos móviles: Teléfonos, PDA, etc.
Para sistemas de servidor.

Sun lanzó la primera versión pública como Java 1.0 en 1995. Con la aparición de Java 2 (lanzado inicialmente como J2SE 1.2 en 1998), las versiones nuevas tuvieron diversas configuraciones en función del tipo de plataforma a las que estaban orientadas.

J2SE: Edición estándar de Java (Java 2 Standard Edition).
J2ME: Desarrollo de aplicaciones para dispositivos móviles (Java 2 Mobile Edition).
J2EE: Desarrollo de aplicaciones empresariales (Java 2 Enterprise Edition).

A partir de 2006 las nuevas versiones de Java 2 se renombraron como Java SE, Java ME y Java EE, respectivamente.
En 2009, ha aparecido JavaFX orientado al desarrollo de aplicaciones de Internet, ejecutables en distintos tipos de dispositivos, con el fin de competir con Flash de Adobe.

Historia y evolución de los lenguajes de programación

2009-09-15T20:00:00.001+02:00

Los primeros ordenadores programables utilizaban combinaciones de interruptores y cambios en el cableado para establecer el comportamiento de la máquina. Un ejemplo es ENIAC, considerada la primera computadora electrónica de propósito general, que fue presentada en 1946. Fue utilizada para el cálculo de trayectorias de proyectiles, pudiendo resolver, por ejemplo, 5000 sumas en 1 segundo.

Otra forma de indicar las operaciones que debía realizar el ordenador, así como los datos sobre los que debía operar, era mediante tarjetas perforadas. En ellas se realizaban una serie de perforaciones que permitían codificar la información como si fuera un código binario (perforado, no perforado). Un dispositivo lector de tarjetas realiza la lectura columna a columna obteniendo la información que se encuentra codificada en la tarjeta,

Con el fin de facilitar la tarea de realizar la programación surge el lenguaje ensamblador, mediante el cual cada instrucción del lenguaje máquina se convierte en un código nemotécnico más fácil de utilizar por los programadores. Por ejemplo, para indicar al ordenador que realice una suma se debe utilizar la instrucción ADD. Este tipo de lenguaje de programación se considera de bajo nivel por su cercanía con el lenguaje máquina que utiliza internamente el procesador.

Este lenguaje tiene como inconvenientes que requiere un alto conocimiento del funcionamiento interno del ordenador, los programas no son transportables de un tipo de ordenador a otro, y resulta bastante difícil escribir los programas. Por otro lado, tiene la ventaja de que la ejecución de los programas es muy rápida.

Ejemplo de programa "Hola mundo" en lenguaje ensamblador para procesadores x86:

 .model small

 .stack

 .data

 Cadena1 DB 'Hola Mundo.$'

 .code

 programa:

    mov ax, @data

    mov ds, ax

    mov dx, offset Cadena1

    mov ah, 9

    int 21h

 end programa

A medida que los programas van siendo más complejos, la programación en ensamblador se va haciendo más complicada, así como la tarea de mantenimiento de la programas escritos en ese lenguaje. Por ello van apareciendo otros lenguajes llamados de alto nivel que se asemejan más al lenguaje humano.

Los programas escritos en lenguajes de alto nivel son más fáciles de escribir por los programadores y realizar su mantenimiento, pueden ser ejecutados en distintos tipos de ordenadores sin tener que modificar el código y no requieren un alto nivel de conocimiento del funcionamiento interno del ordenador. Pero las instrucciones escritas en esos lenguajes deben ser traducidas a lenguaje máquina para que puedan ser comprendidas por el procesador, por lo que es necesario utilizar programas traductores como los compiladores o intérpretes.

Uno de los primeros lenguajes de alto nivel que aparecieron, sobre el año 1955, y que tuvo una gran difusión fue Fortran. Este lenguaje se considera de propósito general, aunque estaba especialmente orientado al cálculo numérico y científico.

Ejemplo de programa "Hola mundo" escrito en Fortran:

PROGRAM HOLA

   PRINT *, '¡Hola, mundo!'

END

Otros lenguajes de propósito general que han sido amplamente utilizados: Basic (1964), Pascal (1970), C (1972), C++ (1983), Perl (1987), Java (1995), etc.

Han aparecido también lenguajes que, en vez que tener un enfoque de propósito general, están especializados en el desarrollo de aplicaciones de un determinado tipo. Por ejemplo, Cobol (1960) está orientado al sector empresarial, Prolog (1972) a la inteligencia artificial, SQL (1978) a la gestión de bases de datos, PHP (1995) al desarrollo web, etc.

Linea de tiempo de la historia de los lenguajes de programación (en inglés)

Qué es un lenguaje de programación

2009-09-15T19:58:00.001+02:00

Es un lenguaje diseñado para expresar instrucciones que deben ser ejecutadas por un ordenador. Por tanto, los lenguajes de programación pueden ser usados para crear programas que controlen el funcionamiento de un ordenador.

Dichos lenguajes están formados por un conjunto de símbolos y de una serie de reglas sintácticas y semánticas para definir qué estructuras son válidas y cuál es su significado.

Los procesadores usados en los ordenadores sólo son capaces de entender y actuar según lo indican programas escritos en un lenguaje llamado lenguaje máquina. Cada tipo de procesador tiene su propio lenguaje máquina. Por ejemplo, un PC con un procesador Intel tiene un determinado lenguaje máquina, y un ordenador Macintosh con un procesador PowerPC tendrá otro lenguaje máquina diferente.

El lenguaje máquina es una secuencia de valores binarios (formados por dos posibles valores), ya que los ordenadores sólo pueden operar distinguiendo dos posibles estados, por ejemplo, recibir un impulso eléctrico y no recibirlo. Para que los humanos podamos operar de alguna manera con ese tipo de lenguaje, se utiliza un sistema numérico binario en el que se utilizan únicamente los valores 0 y 1. De esta forma podemos decir que un 0 podría indicar que no hay impulso eléctrico y un 1 podría significar que sí lo hay. De esta forma un posible ejemplo imaginario de una instrucción máquina podría ser 011001000011, que podría significar que sume los valores 4 y 3.

Evidentemente, utilizar ese tipo de lenguaje para los humanos es muy incómodo, aunque para los ordenadores sea lo mejor. Por ello surgen los lenguajes de programación con el fin de acercar el lenguaje máquina al tipo de lenguaje que solemos utilizar. Un ejemplo imaginario de una instrucción basada en un lenguaje de programación podría ser algo como: ADD 4, 3 que realizaría la misma operación que la anterior, pero para nosotros puede ser mucho más inteligible.

El problema que surge es que los lenguajes de programación deben ser comprensibles por el ordenador, por lo que debe utilizarse un traductor que convierta las instrucciones que contiene un programa escrito en un determinado lenguaje de programación al lenguaje máquina que utiliza directamente el ordenador. Ese traductor suele ser un tipo de programa llamado compilador o intérprete.

Por ejemplo, un programa que muestre en el monitor del ordenador el saludo "Hola Mundo!" en lenguaje máquina de un PC, podría ser algo como esto representado en binario:

11101011 00010010
01001000 01101111 01101100 01100001 00100000 01001101 01110101 01101110 01100100 01101111 00100001 00100100
10110100 00001001
10111010 00000010 00000001
11001101 00100001
10110100 00000000
11001101 00100001

En cambio, ese mismo programa es mucho más claro para nosotros si utilizamos un lenguaje de programación como Java:

class HolaMundo
{

public static void main(String args[])
{

System.out.println("Hola Mundo!");

}

}

Puedes encontrar más ejemplos de este mismo programa escrito en multitud de lenguajes de programación en la página Ejemplos de implementación del Hola mundo en diferentes lenguajes.

Crear un applet Java con NetBeans

2009-05-12T12:47:00.001+02:00

Los applets Java son programas Java que pueden ejecutarse desde una página web. Es posible crearlos desde NetBeans de forma gráfica de forma similar a los programas de escritorio, es decir, utilizando formularios y colocando de forma visual los elementos que van a formar parte del programa.

Para empezar, se debe crear una Aplicación Java de forma similar a la utilizada para las aplicaciones de escritorio: Archivo > Proyecto nuevo > Categoría Java > Aplicación Java.

Se indica el nombre del proyecto que se va a crear, así como la carpeta de destino, y así se termina con la creación del proyecto.

En el proyecto recién creado, hay que añadir un formulario JApplet sobre el que se añadirán los elementos que formarán la aplicación. Para ello se puede utilizar el menú contextual sobre el paquete utilizado, seleccionando la opción "Nuevo" y eligiendo la opción "Formulario JApplet" (si no se encuentra en la lista hay que buscarlo en la opción "Otro").

Al nuevo formulario se le debe indicar un nombre.

En caso se que haya creado el proyecto creando de forma automática una clase principal, ésta debería ser eliminada, ya que el formulario creado anteriormente será la clase que inicie la ejecución del applet anque no tenga un método main.

En el formulario JApplet creado antes se incluirán los elementos que formen parte de la aplicación y el código necesario de forma similar al método utilizado para crear aplicaciones de escritorio.

Una vez diseñado el formulario se debe crear la página web que va a contener el applet. En este caso, se debe crear un archivo HTML fuera del paquete que contiene el applet, es decir, se debe hacer en "Paquetes de fuentes".

Indicar el nombre del archivo que contendrá el applet, en el que no es necesario indicar la extensión html.

La estructura del proyecto debe ser parecida a la siguiente:

El código de la página web debe contener la siguiente línea en el lugar donde se desea que aparezca el applet:
<applet code="appletejemplo.VentanaPpal" archive="AppletEjemplo.jar" width="200" height="100"></applet>

El código puede variar en función de los nombres asignados al proyecto creado y a los nombres asignados a los archivos. Tras el atributo code se debe indicar el nombre de la clase principal en el proyecto, y en caso de que se encuentre dentro de un paquete, se debe indicar su nombre precediendo al nombre de la clase con un punto. Tras el atributo archive se debe indicar el nombre del proyecto seguido de la extensión jar.

Una vez guardados todos los cambios y compilado el proyecto es el momento de probar su funcionamiento. En la carpeta "build" aparece el archivo html junto con las carpetas que contienen las clases compiladas.

Haciendo doble clic sobre la página web ("index.html" en este ejemplo) se abrirá el navegador web con la página web que contiene el applet creado.

Principales eventos de ratón

2009-04-15T14:37:00.001+02:00

Para obtener información de una acción del ratón sobre un determinado elemento de la ventana, o sobre una ventana, se debe crear un método asociado al evento deseado.

Para crear ese tipo de métodos desde NetBeans se dispone del menú contextual o la ventana de Propiedades de la parte derecha que dispone de una pestaña Eventos.

Al crear uno de estos métodos, automáticamente se define un parámetro que recoge información sobre el evento producido. Ese parámetro recibe el nombre evt si se crea automáticamente con NetBeans. Ese es el nombre que debe utilizarse para llamar a los métodos.

Por ejempo, uno de los métodos puede ser:

private void formMouseMoved(java.awt.event.MouseEvent evt)

Eventos

mouseMoved: se ha movido el ratón.
mouseClicked: se ha hecho clic con algún botón del ratón.
mouseWheelMoved: se ha movido la rueda del ratón.
mouseDragged: se ha movido el ratón manteniendo pulsado algún botón.
mousePressed: se ha pulsado algún botón.
mouseReleased: se ha soltado algún botón.
mouseEntered: el puntero del ratón está sobre el elemento en el que está definido el evento.
mouseExited: el puntero del ratón ha dejado de estar sobre el elemento en el que está definido el evento.

Métodos

evt.getX() y evt.getY() permiten obtener la posición (coordenadas X e Y) en la que se encuentra el puntero del ratón respecto al objeto donde se haya definido el evento.
evt.getButton() retorna un valor entero con el número del botón pulsado (1: izquierdo, 2: central o rueda, 3: derecho).
evt.getClickCount() retorna el número de clic seguidos que se han realizado.
evt.getWheelRotation() retorna 1 cada vez que se mueve la rueda hacia atrás y -1 si se hace hacia delante.

Ejemplo

    private void panel1MouseClicked(java.awt.event.MouseEvent evt)

    {

        System.out.print("Se ha hecho clic en: ");

        System.out.println(evt.getX() + "," + evt.getY());

        System.out.print("Con el botón: ");

        switch(evt.getButton())

        {

            case 1:

                System.out.println("izquierdo");

                break;

            case 2:

                System.out.println("central o la rueda");

                break;

            case 3:

                System.out.println("derecho");

                break;

        }

        System.out.print("Se ha pulsado ");

        System.out.println(evt.getClickCount() + " veces seguidas");

    }

Movimiento de gráficos mediante teclas en Java

2009-04-14T12:38:00.001+02:00

La explicación del movimiento de un gráfico en Java mediante la pulsación de teclas está basada en este caso en un ejemplo similar al utilizado en el artículo "Movimiento de gráficos mediante botones en Java", por lo que debe utilizarse esa otra explicación para conocer los atributos y métodos creados en el panel que se ha utilizado para la bola que se va a mover.

Descarga del ejemplo completo.

En la ventana principal se debe realizar el control de las teclas pulsadas. Para ello se declara el controlador de eventos de pulsaciones del teclado. Una de las formas más sencillas es a través del menú contextual de la ventana: Eventos > Key > KeyPressed. Es importante asegurarse que se hace sobre la ventana y no sobre un componente de ella ya que se asignaría el control del teclado sólo a ese componente.

Este tipo de evento (keyPressed) se repite mientras se mantenga pulsada la tecla. Si se desea un evento que sólo sea llamado con cada pulsación de la tecla se debe usar keyReleased.

Otra forma de asignar código al evento es mediate la ventana Eventos de la parte derecha:

Al asignar un controlador a uno de esos eventos se abre el editor de código donde se deben escribir las sentencias que se ejecutarán al pulsar una tecla.

    private void formKeyPressed(java.awt.event.KeyEvent evt)                                

    {                                    

       switch(evt.getKeyCode())

       {

           case KeyEvent.VK_RIGHT:

               tablero1.moverDerecha();

               break;

           case KeyEvent.VK_LEFT:

               tablero1.moverIzquierda();

               break;

           case KeyEvent.VK_UP:

               tablero1.moverArriba();

               break;

           case KeyEvent.VK_DOWN:

               tablero1.moverAbajo();

               break;

       }

    }

El parámetro evt que aparece permite distinguir qué tecla se ha pulsado, a través de su método getKeyCode(). Este método retorna un valor entero con el código de la tecla que se ha pulsado. Si se conoce el valor del código de la tecla deseada se puede hacer una comparación directamente con el valor numérico. Es más cómodo utilizar las contantes que ya están declaradas para los códigos de teclas (KeyEvent.VK_nombreTecla). Para conocer los nombres de teclas que existen, en NetBeans se tiene la ventaja de que al escribir KeyEvent seguido del punto aparecen todas las constantes y métodos que tiene definidas.

En este ejempo se ha utilizado la sentencia switch para realizar las comparaciones, pero es posible hacer cualquier otro tipo de comparación como if o utilizarlo en bucles.

Movimiento de gráficos mediante botones en Java

2009-04-14T11:51:00.001+02:00

Se debe partir de un panel (jPanel) integrado en una ventana (jFrame) tal como se ha explicado en el artículo Gráficos en Java.

Esta explicación se basa en un ejemplo que realiza el movimiento de una bola utilizando cuatro botones para subir, bajar y desplazar a la derecha e izquierda. Descarga del ejemplo completo para NetBeans.

Hay declarados dos atributos en la clase Tablero (jPanel) con las coordenadas donde se debe mostrar la bola, que inicialmente están inicializados para que se muestre en la parte central del tablero. A través de la actualización de los valores de esos atributos se realizará el movimiento de la bola.

public class Tablero extends javax.swing.JPanel {

    private int posX = 45;

    private int posY = 45;

La bola se dibujará en el método paint utilizando las coordenadas anteriores, con un tamaño 10.

    public void paint(Graphics g)

    {

        super.paint(g);

        g.fillOval(posX, posY, 10, 10);

    }

En el códido del panel se han definido una serie de métodos que realizan las operaciones de movimiento deseado. En cada movimiento se modifica el atributo correspondiente para cambiar la posición de la bola y se hace la llamada al método repaint para que se ejecute de nuevo el código del paint visto antes y que se encarga de mostrar la bola.

    public void moverArriba()

    {

        posY--;

        repaint();

    }

    public void moverAbajo()

    {

        posY++;

        repaint();

    }

    public void moverDerecha()

    {

        posX++;

        repaint();

    }

    public void moverIzquierda()

    {

        posX--;

        repaint();

    }

Los botones que permiten al usuario realizar el movimiento se han incluido en la ventana, fuera del panel.

A cada botón se le ha asignado el código necesario para que realice la llamada al método que corresponda del panel para hacer el movimiento de la bola.

    private void botonArribaActionPerformed(java.awt.event.ActionEvent evt)

    {                                                

        tablero1.moverArriba();

    }                                           

    private void botonAbajoActionPerformed(java.awt.event.ActionEvent evt)

    {                                               

        tablero1.moverAbajo();

    }                                          

    private void botonIzquierdaActionPerformed(java.awt.event.ActionEvent evt)

    {                                                   

        tablero1.moverIzquierda();

    }                                              

    private void botonDerechaActionPerformed(java.awt.event.ActionEvent evt)

    {                                                 

        tablero1.moverDerecha();

    }

Hay que observar el nombre que ha recibido el panel al integrarlo en la ventana. En este caso le ha dado el nombre tablero1. Este nombre puede verse en las propiedades al seleccionar el panel.

Mostrar imágenes en Java

2009-04-13T17:32:00.001+02:00

Dentro del método paint de un panel se puede insertar el código para que se cargue una imagen almacenada en un archivo, para que sea mostrada dentro de dicho panel.

Para incluir una imagen se debe llamar al método drawImage de la clase Graphics. A este método se le pasan cuatro parámetros: El primero de ellos es la referencia al objeto Image o BufferedImage que contiene la imagen a mostrar. El segundo y tercer parámetro indican la posición en la que se mostrará.

Para crear el objeto de la clase Image o BufferedImage se puede utilizar el método read de la clase ImageIO, al que se le para la referencia a un objeto File con la ruta al archivo que contiene la imagen.

    public void paint(Graphics g)

    {

        super.paint(g);

        BufferedImage img = null;

        int posx=0, posy=0;

        try 

        {

            img = ImageIO.read(new File("src/recursos/ejemplo.png"));

        } 

        catch (IOException e) 

        {

            //Control de excepción si no se encuentra el archivo

        }

        g.drawImage(img, posx, posy, null);

    }

En este ejemplo se mostraría la imagen "ejemplo.png" que se encuentra en la carpeta "src/recursos" del proyecto. Se indica la posición 0,0 por lo que aparecerá en la esquina superior izquierda del panel.

Principales métodos de la clase Graphics de Java

2009-03-30T17:55:00.001+02:00

Métodos	Descripción
drawLine(int x1, int y1, int x2, int y2)	Dibuja un línea con el color actual desde la posición (x1,y1) hasta (x2,y2)
drawRect(int x, int y, int width, int height)	Dibuja un rectángulo sin relleno desde la posición (x,y) con ancho width y alto height
fillRect(int x, int y, int width, int height)	Dibuja un rectángulo con relleno del color actual, desde la posición (x,y) con ancho width y alto height
drawOval(int x, int y, int width, int height)	Dibuja una elipse sin relleno desde la posición (x,y) con ancho width y alto height
fillOval(int x, int y, int width, int height)	Dibuja una elipse con relleno del color actual, desde la posición (x,y) con ancho width y alto height
drawPolygon(int[] xPoints, int[] yPoints, int nPoints)	Dibuja un polígono sin relleno con nPoints puntos, cuyas coordenadas están en los arrays xPoints e yPoints
fillPolygon(int[] xPoints, int[] yPoints, int nPoints)	Dibuja un polígono con relleno del color actual con nPoints puntos, cuyas coordenadas están en los arrays xPoints e yPoints
drawPolyline(int[] xPoints, int[] yPoints, int nPoints)	Dibuja una línea quebrada con nPoints puntos, cuyas coordenadas están en los arrays xPoints e yPoints
setColor(Color c)	Establece el color actual al color especificado. El color puede ser uno de los predefinidos usando Color.nombreColor Es posible crear nuevos colores indicando en el parámetro new Color(r,g,b) con la combinación de colores rojo (r), verde (g) y azul (b) de 0 a 255.
drawString(String str, int x, int y)	Muestra el texto str en la posición (x,y)
setFont(Font font)	Estable el tipo de fuente para el texto. Es posible indicar un tipo de fuente con el constructor: Font(String name, int style, int size)

Gráficos en Java

2009-03-30T17:07:00.001+02:00

Una de las formas de manejar gráficos en Java es crear un objeto JPanel, sobre el que se realizarán las operaciones de dibujo, y luego integrarlo en una ventana JFrame con NetBeans.

Para ello, en el proyecto de NetBeans se debe crear un nuevo "Formulario JPanel".

Una vez creado el JPanel se debe crear, dentro de su código fuente, el método paint, el cual será un método que sobreescribe el que posee dicha clase.

Se debe indicar de la siguiente forma:

(Una forma automática de escribir este código es utilizar el menú Fuente > Insertar código > Redefinir método, y dentro del objeto JComponent seleccionar el método paint y hacer clic en el botón Generar).

Es un método público (public), que no retorna ningún valor (void) y al que se pasa como parámetro un objeto de la clase Graphics al que se le llama g.

Este método es llamado automáticamente cuando se muestra en pantalla el panel, o bien, se puede utilizar en un momento determinado cuando se llama desde el código al método repaint.

En el método conviene hacer una llamada al mismo objeto de la clase padre (super.paint(g)) para que se muestren los objetos que tenga asociados el panel. Posteriormente se pueden escribir las sentencias que creen el dibujo. Un ejemplo de dichas sentencias puede ser:

g.drawLine(20, 10, 30, 50);

que dibuja una línea desde la posición (20,10) hasta la (30,50).

Hay que tener en cuenta que la posición (0,0) está en la esquina superior izquierda del panel.

Todos los métodos de la clase Graphics que se vayan a utilizar para realizar el dibujo deben llamarse indicando el objeto g, o el que se haya especificado en el parámetro del método paint, utilizando el formato:

g.nombreMétodo(parámetros);

Tras escribir el código fuente es el momento de integrar ese JPanel en el diseño de un formulario JFrame que debe crearse dentro mismo proyecto. Para ello, basta con hacer clic sobre el JPanel en el explorador de Proyectos de la parte izquierda, y arrastrarlo dentro de la ventana JFrame en el lugar deseado.

Se pueden consultar todos los métodos de la clase Graphics en la API de Java.

Añadir espacios de relleno a un String en Java

2009-03-25T19:39:00.001+01:00

Si se desea que un String tenga un tamaño determinado, rellenando con espacios al final hasta un número de caracteres determinado se puede utilizar el método format de la clase String con la siguiente cadena de formato:

String.format("%1$-10s",cadena);

(Se debe sustituir el 10 por el tamaño deseado, y cadena debe ser la variable de tipo String o la cadena literal entre comillas sobre el que se desea aplicar el relleno).

En este ejemplo se asigna un tamaño de 10 caracteres para el String llamado cadena. Si esa cadena tuviera menos de esos 10 caracteres la sentencia anterior devolvería un String con dicha cadena seguida de los espacios necesarios hasta rellenar los 10 caracteres. En caso de que la cadena tuviera más de 10 caracteres, dicha sentencia devuelve la cadena tal cual, es decir, no la corta a 10 caracteres. Para eso habría que utilizar el método substring.

El guión que se indica delante del 10 permite que los espacios de relleno se coloquen detrás de la cadena. Si se desea que el relleno se coloque delante se debe eliminar ese guión.

Ventana de selección de archivos en Java

2009-03-23T11:27:00.002+01:00

La clase JFileChooser (Requiere importar javax.swing.JFileChooser) permite abrir una ventana de diálogo en la que el usuario pueda seleccionar un archivo para realizar una acción sobre él (por ejemplo, abrirlo).

        //Crear un objeto FileChooser

        JFileChooser fc = new JFileChooser();

        //Mostrar la ventana para abrir archivo y recoger la respuesta

        //En el parámetro del showOpenDialog se indica la ventana

        //  al que estará asociado. Con el valor this se asocia a la

        //  ventana que la abre.

        int respuesta = fc.showOpenDialog(this);

        //Comprobar si se ha pulsado Aceptar

        if (respuesta == JFileChooser.APPROVE_OPTION)

        {

            //Crear un objeto File con el archivo elegido

            File archivoElegido = fc.getSelectedFile();

            //Mostrar el nombre del archvivo en un campo de texto

            txtNombre.setText(archivoElegido.getName());

        }

Si en vez de utilizar la ventana de diálogo para abrir un archivo se desea utilizar la ventana para guardar un archivo se debe utilizar el método showSaveDialog en vez de showOpenDialog.

         int respuesta = fc.showSaveDialog(this);

Para seleccionar directorios en vez de archivos hay que utilizar el siguiente método antes de llamar a ShowOpenDialog o ShowSaveDialog:

        fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);

Es posible modificar el directorio que se muestra al abrir la ventana utilizando el método setCurrentDirectory al que se le debe pasar por parámetro un objeto File con la ruta del directorio.

        //Cambiar al direcrio Windows

        fc.setCurrentDirectory(new File("c:/windows/"));

        //O bien usando dos barras invertidas

        fc.setCurrentDirectory(new File("c:\\windows\\"));

Principales métodos de la clase File

2009-03-19T18:57:00.001+01:00

Método constructor

File(String rutaFichero)

Parámetro:

rutaFichero: ruta completa y nombre del archivo del que se desea crear un objeto File. Debe utilizarse la barra / para separar los directorios en la ruta, en vez de la barra invertida típica de las rutas en Windows.

Métodos sobre directorios y archivos

boolean isDirectory()

Acción: Comprobar si el objeto es un directorio.
Retorna: true si el objeto es un directorio y false si es un archivo.

boolean mkdir()

Acción: Crear el directorio especificado como rutaFichero en el constructor.
Retorna: true si se ha creado el directorio y false en caso contrario.

String[] list()

Acción: Obtener la lista de archivos que hay en el directorio.
Retorna: Un array de tipo String con la lista de los nombres de archivos.

File[] listRoots()

Acción: Obtener la lista de directorios raíz (Unidades de disco/particiones en Windows). Es un método static por lo que debe ser llamado directamente con la clase File, no con un objeto.
Retorna: Un array de tipo File con la lista de los volúmenes del sistema.

String getPath()

Acción: Obtener la ruta del objeto.
Retorna: Una cadena de caracteres con la ruta.

boolean delete()

Acción: Borrar el archivo o directorio al que hace referencia el objeto que llama a este método.
Retorna: true si el archivo o directorio ha sido borrado, y false en caso contrario.

boolean exists()

Acción: Comprobar si el archivo o directorio al que hace referencia el objeto que llama a este método existe o no.
Retorna: true si el archivo o directorio existe, y false en caso contrario.

String getName()

Acción: Obtener el nombre del objeto.
Retorna: El nombre del archivo o directorio.

long length()

Acción: Obtener el tamaño del objeto.
Retorna: Dicho tamaño.

boolean renameTo(File dest)

Acción: Cambier el nombre de un archivo o directorio.
Parámetro:

dest: Objeto de tipo File que hace referencia al nuevo nombre que debe tener el archivo o directorio.

Retorna: true si se ha podido cambiar el nombre, y false en caso contrario.

Más métodos e información en la API de Java - Clase File . Ejemplo:

/Obtener la lista de archivos y directorios
//  del directorio actual
File dirActual = new File(".");
String[] lista = dirActual.list();
for (int i = 0; i < lista.length; i++)
{
   File f = new File(lista[i]);
   System.out.println("Nombre: "+f.getName());
   System.out.println("Tamaño: "+f.length());
   if(f.isDirectory())
       System.out.println("Es un directorio");
   else
       System.out.println("Es un archivo");
   System.out.println("-------------------");
}

//Comprobar si existe el archivo "prueba.txt"
File prueba = new File("prueba.txt");
if(prueba.exists())
   System.out.println("El archivo prueba.txt existe");
else
   System.out.println("El archivo prueba.txt NO existe");

Establecer botón por defecto en Java

2009-03-16T21:16:00.005+01:00

Normalmente, en las ventanas de diálogo, se suele tener un botón activado por defecto, de manera que al pulsar Intro es como hacer clic con el ratón sobre él. Para indicar cuál es el botón por defecto en una ventana se puede utilizar el siguiente código: getRootPane().setDefaultButton(nombreDelBotón); Siendo nombreDelBotón el nombre que se le haya dado al objeto jButton que se desea tener activado por defecto. Un buen lugar para colocar esta sentencia puede ser detrás del initComponents() que se encuentra en el método constructor de la ventana.

Acceso directo a un fichero en Java

2009-03-12T13:35:00.003+01:00

(Se debe importar java.io.RandomAccessFile)

try
{
    //La variable pos va a marcar desde donde se accede al fichero
    int pos = 10;
    //Los caracteres leídos se toman como entero
    int caract;
    //Se abre el fichero para lectura y escritura
    RandomAccessFile raf = new RandomAccessFile("directo.txt","rw");
    //Obtener el tamaño del fichero
    long tamaño = raf.length();

    //Posicionar el puntero del fichero en la posición indicada
    raf.seek(pos);
    //Bucle mientras no se alcance el final del fichero
    while(raf.getFilePointer()<tamaño)
    {
        //Leer un carácter y avanzar puntero al siguiente carácter
        caract = raf.read();
        //Mostrar en pantalla el carácter leído
        System.out.print((char)caract);
        //Retroceder una posición
        raf.seek(raf.getFilePointer()-1);
        //Escribir el carácter leído convertido a mayúsculas
        raf.write(Character.toUpperCase(caract));
    }
    //Para leer una línea entera se usa readLine
    //y usar writeBytes para escribir un String
    raf.writeBytes("Fin del fichero");
    //Cerrar el fichero
    raf.close();
}
catch(Exception e)
{
    System.out.println("Error de acceso al fichero");
}