martes, 6 de octubre de 2009

Operadores de asignación

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

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

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.

Variables
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:
palabrasReservadas
  • 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);





lunes, 5 de octubre de 2009

Operadores y expresiones de caracteres y cadenas de caracteres

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



jueves, 1 de octubre de 2009

Operadores y expresiones relacionales y lógicos

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:
  1. !
  2. &&
  3. || 
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.
  1. Operadores aritméticos (* / % + -)
  2. Operadores relacionales (< <= > >= == !=)
  3. 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.

martes, 29 de septiembre de 2009

Operadores y expresiones aritméticas

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:
  1. Multiplicación (*), División (/) y Resto (%)
  2. 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.


lunes, 28 de septiembre de 2009

Inserción de comentarios en el código fuente

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
     */

 

Contador de visitas