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 Descripción Tamaño

Reservada en
JAVA
byte Entero c/longitud 8-bit
byte
short Entero corto 16-bit
int Integer 32-bit
long Entero largo 64-bit
float Punto flotante 32-bit
simple p.
double Punto flotante doble 64-bit
p.
 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

 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:

Operado Uso Descripción

r
++ 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:

Operado Uso Retorna verdadero si

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

Operado Uso Operación

r
>> 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 >>> Cambia bits de op1 a la derecha basado en
op2 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 + ".");

}
}