Estructuras de

control Java
Fundamentos del Lenguaje
1. Variables.

2. Operadores.

3. Expresiones.

4. Instrucciones.

5. Bloques.
 Variables
 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
 Tipos de Datos
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
 Tipo de Datos primitivo
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 Descripción Tamaño

en JAVA
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
 Ejemplos primitivos
 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);
}
}
 Cont. De ejemplos
 //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 promocion
 //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);
}
}
 Tipo de datos Referencia
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.
Tipo de datos Referencia (2)
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.
 Constantes (final)
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.
 Operadores
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.

 Operadores Aritméticos
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.
 Operadores Aritméticos 2
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.

 Operadores Relacionales
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
 Operadores Condicionales
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.
 Operadores de Cambio
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)
 Operadores Bitwise
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
 Operadores de Asignación
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
 Otros Operadores
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).
 Expresiones
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 (Sentencias)
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.
Instrucciones 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).
 While y Do-While
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.
 Do - While
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.
 Instrucción For
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.
 If/Else
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)
}
 La Instrucción Switch
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.
 Manejo de Excepciones
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.
Instrucciones de Ramificación

El lenguaje de programación Java soporta tres

instrucciones de ramificación:

 Break

 Continue

 Return.
 Instrucción Break
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.
 Instrucción Continue
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:
 Instrucción Return
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;
 Ejemplos:
 // 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 + ".");

}
}