El documento describe los conceptos básicos de variables, tipos de datos, operadores y expresiones en Java. Explica que las variables deben declararse con un tipo de dato primitivo o referencial y que existen 8 tipos de datos primitivos como enteros, flotantes y caracteres. También describe los diferentes tipos de operadores como aritméticos, relacionales, lógicos y de asignación que pueden usarse con variables, así como el concepto de expresiones. Finalmente, introduce brevemente los conceptos de instrucciones, bloques de código y manejo de excepc

2. 1. Variables.
2. Operadores.
3. Expresiones.
4. Instrucciones.
5. Bloques.

3.  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 bits
short y; // Entero corto de 16 bits

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

5. 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-bit
short Entero corto 16-bit
int Integer 32-bit
long Entero largo 64-bit
float Punto flotante simple p. 32-bit
double Punto flotante doble p. 64-bit
char Un carácter simple 16-bit
boolean Un carácter booleano true o false

6.  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);
}
}

7.  //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);
}
}

8.  //Ejemplo de promocion de valores de diferentes tipos
class 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);
}
}

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

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

11. Se puede declarar una variable en cualquier ámbito para que sea final.
El valor de una variable final no puede cambiar después de que ha sido
inicializada. Tales variables son similares a las constantes en otros lenguajes.
Para declarar una variable final, emplee la palabra reservada final 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.

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

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

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

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

16. 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:
Operado
r
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.

17. 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.
Operado
r
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)

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

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

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

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

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

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

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

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

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

27. 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)
}

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

29. 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)
} finally {
statement(s)
}
En otro apartado ampliaremos este tema.

30. El lenguaje de programación Java soporta tres
instrucciones de ramificación:
 Break
 Continue
 Return.

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

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

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

34.  // 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.");
}
}

35.  // 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);
}
}

36.  //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 + ".");
}
}