1. Variables.

2. Operadores.

3. Expresiones.

4. Instrucciones.

5. Bloques.

El nombre de variable debe ser un identificador válido, -- un número ilimitado de caracteres Unicode que comienza con una letra.

El tipo de variable determina que valores puede contener y que operaciones se pueden realizar en ella.

Para dar a una variable un nombre y un tipo, se escribe una declaración de variable, la cual aparecería como:

Ejs: int x; // Entero de 32 bitsshor t y; // Entero corto de 16 bits

En el lenguaje de programación Java, existen dos categorías de datos:

Primitivos

Referenciales

Una variable de tipo primitivo contiene un valor simple del tamaño y formato apropiado para su tipo: un número, un carácter, o un valor booleano (condicional verdadero ó falso), etc

La siguiente tabla lista, por palabras reservadas, todos los tipos de datos primitivos soportados por Java, sus tamaños y formatos, y una breve descripción de cada uno:

Palabra Reservada en

JAVA

Descripción Tamaño

byte Entero c/longitud byte 8-bitshort Entero corto 16-bitint Integer 32-bitlong Entero largo 64-bitfloat Punto flotante simple p. 32-bitdouble Punto flotante doble p. 64-bitchar Un carácter simple 16-bitboolean Un carácter booleano true o false

Ejemplo21: Calcular cuanto recorre la velocidad de la luz en 1000 días. Ejemplo22: Calcular el área de un circulo. //Ejemplo de uso de char

class Ejemplo23 { public static void main(String args[]) { char ch1, ch2;

ch1 = 88; // codigo de x ch2 = 'Y'; System.out.print("ch1 y ch2: "); System.out.println(ch1 + " " + ch2); }}

//Ejemplo de conversion(cast)class Ejemplo24 { public static void main(String args[]) { byte b; int i = 257; double d = 323.142; System.out.println("\nConversion de int a byte."); b = (byte) i; System.out.println("i y b " + i + " " + b);

System.out.println("\nConversion de double a int."); i = (int) d; System.out.println("d y i " + d + " " + i);

System.out.println("\nConversion de double to byte."); b = (byte) d; System.out.println("d y b " + d + " " + b); }}

//Ejemplo de promocion de valores de diferentes tiposclass Ejemplo25 { public static void main(String args[]) { byte b = 42; char c = 'a'; short s = 1024; int i = 50000; float f = 5.67f; double d =0.1234; double resultado = (f * b) + (i / c) - (d * s); System.out.println((f * b) + " + " + (i / c) + " - " + (d * s)); System.out.println("resultado = " + resultado); }}

Una referencia es denominada apuntador ó dirección de memoria en otros lenguajes.

Java no soporta el uso explicito de apuntadores como otros lenguajes. Se emplea el nombre de variable en su lugar.

Public class MiFecha{ int dia; int mes; int año;

// Podemos usar MiFecha como sigue:  public static void main(String[] args) { MiFecha hoy = new MiFecha(); hoy.dia=21; hoy.mes=8; hoy.año=2008; System.out.println("la fecha es :" +hoy.dia+"/"+hoy.mes+"/"+hoy.año);}} La variable hoy es una referencia a un objeto de MiFecha.

Se puede declarar una variable en cualquier ámbito para que sea f inal .

El valor de una variable f inal no puede cambiar después de que ha sido inicializada. Tales variables son similares a las constantes en otros lenguajes.

Para declarar una variable f inal, emplee la palabra reservada f inal antes del tipo:

Ej.

final int aFinalVar = 0;

En el caso del ejemplo, se ha declarado e inicializado la variable en un solo paso. Se puede hacer en dos pasos si se prefiere. Hecho esto, si se intenta asignar posteriormente un valor a ésta variable, produciría un error de compilación.

Un operador realiza una función en uno, dos o tres operandos. Un operador que requiere un operando es denominado operador unario.

Ej. ++ es un operador unitario que incrementa en uno el valor de su operando.

Un operador que requiere dos operandos es un operador binario.

Ej. = es un operador binario. Se usa para asignación de valores a variables.

Un operador que requiere tres operadores se denomina ternario. Existe un operador ternario ?: que es una abreviación de la instrucción if-else.

Existen también tres modalidades de notación: prefija, postfija e infija.

Java soporta varios operadores aritméticos para todos los números enteros y de punto flotante: + (suma), - (resta), * (multiplicación), / (división) y % módulo.

Operador Uso Descripción

+ op1 + op2 Suma op1 y op2- op1 - op2 Resta op2 de op1* op1 * op2 Multiplica op1 por op2

/ op1 / op2 Divide op1 entre op2% op1 % op2 Calcula el remanente.

Los operadores abreviados de incremento/decremento son sumarizados en la siguiente tabla:

Operador Uso Descripción++ op++ Incrementa op en 1. Asigna primero, incrementa después.++ ++op Incrementa op en 1. Incrementa primero, asigna después.-- op-- Decrementa op en 1. Asigna primero, decrementa

después.-- --op Decrementa op en 1. Decrementa primero, asigna

después.

Un operador relacional compara dos valores y determina la relación entre ellos. Por ejemplo, != retorna verdadero si los dos operandos son diferentes. A continuación una tabla de operadores:

Ej.

Operador Uso Retorna verdadero> op1 > op2 op1 es mayor que op2>= op1 >= op2 op1 es mayor que o igual que op2< op1 < op2 op1 es menor que op2<= op1 <= op2 op1 es menor que o igual que op2== op1 == op2 op1 y op2 son iguales!= op1 != op2 op1 y op2 son diferentes

Los operadores relacionales frecuentemente son empleados con operadores condicionales para construir más complejas expresiones de toma de decisiones.

Java soporta seis operadores condicionales – cinco binarios y uno unario - como aparece en la siguiente tabla:

Operador

Uso Retorna verdadero si

&& op1 && op2 op1 y op2 son ambos verdad. (shortcircuit) | | op1 | | op2 o op1 o op2 es verdad. (shortcircuit)! !op op es falso. & op1 & op2 op1 y op2 son ambos verdad. (non-shortcircuit) | op1 | op2 o op1 o op2 es verdad. (non-shortcircuit) ^ op1 ^ op2 si op1 y op2 son diferentes – esto es si uno u otro

de los operandos es verdad, pero no los dos.

Un operador de cambio realiza transformaciones de manipulaciones de bits en datos cambiando los bits de su primer operando a la izquierda ó la derecha. La tabla a continuación resume los operadores de cambio disponibles en Java.

Operador

Uso Operación

>> op1 >> op2 Cambia bits de op1 a la derecha basado en op2<< op1 << op2 Cambia bits de op1 a la izquierda basado en op2>>> op1 >>> op2 Cambia bits de op1 a la derecha basado en op2

(unsigned)

La siguiente tabla muestra los cuatro operadores que el lenguaje Java provee para realizar lógicas a nivel de bit en sus operandos:

Operador Uso Operación & op1 & op2 Bitwise and

| op1 | op2 Bitwise or

^ op1 ^ op2 Bitwise xor

~ ~op2 Bitwise complement

La siguiente lista la asignación abreviada y sus equivalentes sin abreviar:Operador Uso Equivalente a

+= op1 += op2 op1 = op1 + op2

-= op1 -= op2 op1 = op1 – op2*= op1 *= op2 op1 = op1 * op2/= op1 /= op2 op1 = op1 / op2%= op1 %= op2 op1 = op1 % op2 &= op1 &= op2 op1 = op1 & op2| = op1 | = op2 op1 = op1 | op2^= op1 ^= op2 op1 = op1 ^ op2<<= op1 <<= op2 op1 = op1 << op2>>= op1 >>= op2 op1 = op1 >> op2>>>= op1 >>>= op2 op1 = op1 >>> op2

La siguiente tabla lista los otros operadores que el lenguaje Java soporta:

Operador Descripción ?: Abreviación if - else

[ ] Empleado para declarar arreglos y accesar elementos.

. Usado para formar nombres cualificados

( parametros ) Delimita una lista de parámetros separados por coma

( tipo ) Convierte un valor al tipo especificado

new Crea un nuevo objeto ó un nuevo arreglo

instanceof Determina si su primer operando es una instancia del segundo operando. (descendencia directa o no).

Variables y operadores, los cuales aparecen en las secciones previas, son bloques básicos que conforman los programas. Se pueden combinar literales, variables, y operadores para formar expresiones – segmentos de código que realizan cálculos y retornan valores.

Por definición, una expresión es una serie de variables, operadores y llamadas a métodos (construidas de acuerdo a la sintaxis del lenguaje) que resultan en un valor simple.

Instrucciones son claramente equivalentes a las sentencias en los lenguajes naturales. Una instrucción forma una completa unidad de ejecución. Los siguientes tipos de expresiones pueden ser convertidas en instrucciones finalizando la expresión con un punto y coma, ( ; ).

Expresiones de asignación.

Cualquier uso de ++ ó --.

llamadas a métodos.

Expresiones de creación de objetos.

Hay tres tipos de expresiones: instrucción de expresión, instrucción de declaración e instrucción de control de flujo.

Se pueden emplear instrucciones de flujo para condicionalmente ejecutar instrucciones, para repetidamente ejecutar bloques de instrucciones y para de otro modo cambiar el flujo secuencial de control.

Hay cuatro tipos de instrucciones de control de flujo que son: bucles, de decisión, manejo de excepciones y ramificaciones (branching).

Se debe usar una instrucción while para continuamente ejecutar un bloque de instrucciones mientras una condición permanezca verdadera. La sintaxis general de while es:

while (expression) {

statement

}

Primero, la instrucción while evalúa la expresión, la cual debe retornar un valor booleano. Si la expresión retorna verdadero, entonces la instrucción while ejecuta las instrucciones dentro del bloque asociado. El proceso se mantiene ininterrumpido hasta que la expresión retorne falso.

Esta instrucción es muy similar a la anterior, con la diferencia de que la evaluación de la instrucción se hace al final, no al principio. Esto permite ejecutar aunque sea una vez el bloque asociado sin evaluar la expresión.

La instrucción for provee una forma compacta de iterar sobre un rango de valores. La forma general de la instrucción for puede ser expresada como esto:

for (initialization; termination; increment) { statement

} La inicialización es una expresión que inicializa el bucle. Es ejecutada una vez al comienzo del bucle. La expresión de terminación determina cuando terminar el bucle. Esta expresión es evaluada al tope de cada iteración del bucle. Cuando la expresión evalúa a falso, el bucle termina. Finalmente, la expresión increment es invocada después de cada iteración. Todos esos componentes son opcionales.Los bucles for son frecuentemente utilizados para iterar sobre los elementos de un arreglo, o los caracteres de un String.

La instrucción if / else permite al programa ejecutar selectivamente otras instrucciones, basado en algún criterio. La forma general sería:

if (expression) { statement(s)

}

Se emplea la instrucción switch para condicionalmente ejecutar instrucciones basadas en expresiones de enteros.

La instrucción switch evalúa su expresión, y ejecuta la instrucción case adecuada. Otro punto de interés es la instrucción break después de cada case. Cada instrucción break termina el bloque de switch, y el flujo de control continúa con la primera instrucción que sigue después del bloque de switch. Si no se colocaran instrucciones break, el cursor de ejecución seguiría ejecutando otros bloques case.

El lenguaje de programación Java provee un mecanismo conocido como excepciones para ayudar a los programas a reportar y manejar errores. Cuando un error ocurre, el programa arroja una excepción, lo cual significa que el flujo normal de ejecución a quedado interrumpido y que el entorno de runtime intenta encontrar un manejador de excepciones – un bloque de código que pueda manejar un tipo particular de error. El manejador de excepciones puede intentar recuperar del error ó, si determina que el error es irrecuperable, proveer una finalización gentil del programa. Hay tres instrucciones que juegan un rol en el manejo de excepciones: Try, Catch y Finally.

try { statement(s) } catch (exceptiontype name) { statement(s) } f inally { statement(s) }

En otro apartado ampliaremos este tema.

El lenguaje de programación Java soporta tres instrucciones de ramificación:

Break

Continue

Return.

La instrucción break tiene dos formas: con etiqueta ó sin etiqueta. La forma sin etiqueta es empleada para terminar el bucle interno en que se encuentre, mientras que la forma con etiqueta permite terminar una instrucción marcada con una etiqueta.

La instrucción continue se emplea para saltar (obviar) la iteración actual de un bucle for, while ó do-while. La forma sin etiqueta salta hasta el final del bucle interno y evalúa la expresión booleana que controla el bucle, básicamente obviando el remanente de esta iteración del bucle. La forma con etiqueta salta (obvia) la iteración actual con la etiqueta dada. A continuación unos ejemplos con cada una de las formas:

Se emplea la instrucción return para salir del método actual. El flujo de control retorna a la instrucción que sigue al método llamador. La instrucción return tiene dos formas: una que retorna un valor y otra que no lo hace. Para retornar un valor, simplemente coloque el valor (o una expresión que calcule el valor) después de la palabra reservada return:

return ++count;

El tipo de dato del valor retornado debe ser acorde con el tipo de dato de retorno del método (en su declaración). Cuando un método es declarado void, use la forma de return que no retorna valor.

return;

// ejemplo de un arreglo sencillo.class Ejemplo26 { public static void main(String args[]) { int diasDelMes[]; diasDelMes = new int[12]; diasDelMes[0] = 31; diasDelMes[1] = 29; diasDelMes[2] = 31; diasDelMes[3] = 30; diasDelMes[4] = 31; diasDelMes[5] = 30; diasDelMes[6] = 31; diasDelMes[7] = 31; diasDelMes[8] = 30; diasDelMes[9] = 31; diasDelMes[10] = 30; diasDelMes[11] = 31; System.out.println("Febrero tiene " + diasDelMes[1] + " dias."); }}

// Ejemplo de ++ y --.class Ejemplo27 { public static void main(String args[]) { int a = 1; int b = 2; int c; int d;

c = ++b; d = a++; c++; System.out.println("a = " + a); System.out.println("b = " + b); System.out.println("c = " + c); System.out.println("d = " + d); }}

//ejemplo de if class Ejemplo28 { public static void main(String args[]) { int mes = 4; // abril String estacion; if(mes == 12 || mes == 1 || mes == 2) estacion = "el Invierno"; else if(mes == 3 || mes == 4 || mes == 5) estacion = "la primavera"; else if(mes == 6 || mes == 7 || mes == 8) estacion = "el verano"; else if(mes == 9 || mes == 10 || mes == 11) estacion = "el Otoño"; else estacion = "Mes desconocido";

System.out.println("Abril esta en " + estacion + "."); }}